@codingame/monaco-vscode-api 1.67.19 → 1.67.20

package/dist/missing-services-9c48c894.js

@@ -0,0 +1,3177 @@
+import { VSBuffer as VSBuffer$1 } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { toDisposable, DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Themable as Themable$1 } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ProgressBar as ProgressBar$1 } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
+import { mixin, equals, deepClone, deepFreeze } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { show, hide, trackFocus } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { isNumber, isObject, isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { LanguageService as LanguageService$1 } from 'monaco-editor/esm/vs/editor/common/services/languageService.js';
+import { LanguagesRegistry } from 'monaco-editor/esm/vs/editor/common/services/languagesRegistry.js';
+import { firstOrDefault, distinct, flatten, equals as equals$1 } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { TokenizationRegistry } from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { NoOpNotification } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { v as shuffle, N as NoOpNotification$1, k as IEditorService, n as IPaneCompositePartService, g as IUriIdentityService, b as ITextFileService, e as IFileService, l as IEditorGroupsService, f as IWorkbenchEnvironmentService, h as IWorkingCopyFileService, i as IPathService, I as IProgressService, s as Services, o as IProductService, p as ILanguageStatusService, q as IHostService } from './services-a8445f52.js';
+import { ResourceMap, TernarySearchTree as TernarySearchTree$1 } from 'monaco-editor/esm/vs/base/common/map.js';
+import { compareSubstring, compareSubstringIgnoreCase, compareIgnoreCase, compare as compare$1 } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Configuration as Configuration$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
+import { overrideIdentifiersFromKey, OVERRIDE_PROPERTY_REGEX, Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { getConfigurationValue, addToValueTree, removeFromValueTree, toValuesTree } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { StandaloneConfigurationService } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { QuickInputController } from 'monaco-editor/esm/vs/base/parts/quickinput/browser/quickInput.js';
+import { getSingletonServiceDescriptors, registerSingleton } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ExtUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
+import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
+function isReadableStream(obj) {
+    const candidate = obj;
+    if (!candidate) {
+        return false;
+    }
+    return [candidate.on, candidate.pause, candidate.resume, candidate.destroy].every(fn => typeof fn === 'function');
+}
+function isReadableBufferedStream(obj) {
+    const candidate = obj;
+    if (!candidate) {
+        return false;
+    }
+    return isReadableStream(candidate.stream) && Array.isArray(candidate.buffer) && typeof candidate.ended === 'boolean';
+}
+function newWriteableStream(reducer, options) {
+    return (
+         new WriteableStreamImpl(reducer, options)
+    );
+}
+class WriteableStreamImpl {
+    constructor(reducer, options) {
+        this.reducer = reducer;
+        this.options = options;
+        this.state = {
+            flowing: false,
+            ended: false,
+            destroyed: false
+        };
+        this.buffer = {
+            data: [],
+            error: []
+        };
+        this.listeners = {
+            data: [],
+            error: [],
+            end: []
+        };
+        this.pendingWritePromises = [];
+    }
+    pause() {
+        if (this.state.destroyed) {
+            return;
+        }
+        this.state.flowing = false;
+    }
+    resume() {
+        if (this.state.destroyed) {
+            return;
+        }
+        if (!this.state.flowing) {
+            this.state.flowing = true;
+            this.flowData();
+            this.flowErrors();
+            this.flowEnd();
+        }
+    }
+    write(data) {
+        if (this.state.destroyed) {
+            return;
+        }
+        if (this.state.flowing) {
+            this.emitData(data);
+        }
+        else {
+            this.buffer.data.push(data);
+            if (typeof this.options?.highWaterMark === 'number' && this.buffer.data.length > this.options.highWaterMark) {
+                return (
+                     new Promise(resolve => this.pendingWritePromises.push(resolve))
+                );
+            }
+        }
+    }
+    error(error) {
+        if (this.state.destroyed) {
+            return;
+        }
+        if (this.state.flowing) {
+            this.emitError(error);
+        }
+        else {
+            this.buffer.error.push(error);
+        }
+    }
+    end(result) {
+        if (this.state.destroyed) {
+            return;
+        }
+        if (typeof result !== 'undefined') {
+            this.write(result);
+        }
+        if (this.state.flowing) {
+            this.emitEnd();
+            this.destroy();
+        }
+        else {
+            this.state.ended = true;
+        }
+    }
+    emitData(data) {
+        this.listeners.data.slice(0).forEach(listener => listener(data));
+    }
+    emitError(error) {
+        if (this.listeners.error.length === 0) {
+            onUnexpectedError(error);
+        }
+        else {
+            this.listeners.error.slice(0).forEach(listener => listener(error));
+        }
+    }
+    emitEnd() {
+        this.listeners.end.slice(0).forEach(listener => listener());
+    }
+    on(event, callback) {
+        if (this.state.destroyed) {
+            return;
+        }
+        switch (event) {
+            case 'data':
+                this.listeners.data.push(callback);
+                this.resume();
+                break;
+            case 'end':
+                this.listeners.end.push(callback);
+                if (this.state.flowing && this.flowEnd()) {
+                    this.destroy();
+                }
+                break;
+            case 'error':
+                this.listeners.error.push(callback);
+                if (this.state.flowing) {
+                    this.flowErrors();
+                }
+                break;
+        }
+    }
+    removeListener(event, callback) {
+        if (this.state.destroyed) {
+            return;
+        }
+        let listeners = undefined;
+        switch (event) {
+            case 'data':
+                listeners = this.listeners.data;
+                break;
+            case 'end':
+                listeners = this.listeners.end;
+                break;
+            case 'error':
+                listeners = this.listeners.error;
+                break;
+        }
+        if (listeners) {
+            const index = listeners.indexOf(callback);
+            if (index >= 0) {
+                listeners.splice(index, 1);
+            }
+        }
+    }
+    flowData() {
+        if (this.buffer.data.length > 0) {
+            const fullDataBuffer = this.reducer(this.buffer.data);
+            this.emitData(fullDataBuffer);
+            this.buffer.data.length = 0;
+            const pendingWritePromises = [...this.pendingWritePromises];
+            this.pendingWritePromises.length = 0;
+            pendingWritePromises.forEach(pendingWritePromise => pendingWritePromise());
+        }
+    }
+    flowErrors() {
+        if (this.listeners.error.length > 0) {
+            for (const error of this.buffer.error) {
+                this.emitError(error);
+            }
+            this.buffer.error.length = 0;
+        }
+    }
+    flowEnd() {
+        if (this.state.ended) {
+            this.emitEnd();
+            return this.listeners.end.length > 0;
+        }
+        return false;
+    }
+    destroy() {
+        if (!this.state.destroyed) {
+            this.state.destroyed = true;
+            this.state.ended = true;
+            this.buffer.data.length = 0;
+            this.buffer.error.length = 0;
+            this.listeners.data.length = 0;
+            this.listeners.error.length = 0;
+            this.listeners.end.length = 0;
+            this.pendingWritePromises.length = 0;
+        }
+    }
+}
+function consumeReadable(readable, reducer) {
+    const chunks = [];
+    let chunk;
+    while ((chunk = readable.read()) !== null) {
+        chunks.push(chunk);
+    }
+    return reducer(chunks);
+}
+function peekReadable(readable, reducer, maxChunks) {
+    const chunks = [];
+    let chunk = undefined;
+    while ((chunk = readable.read()) !== null && chunks.length < maxChunks) {
+        chunks.push(chunk);
+    }
+    if (chunk === null && chunks.length > 0) {
+        return reducer(chunks);
+    }
+    return {
+        read: () => {
+            if (chunks.length > 0) {
+                return chunks.shift();
+            }
+            if (typeof chunk !== 'undefined') {
+                const lastReadChunk = chunk;
+                chunk = undefined;
+                return lastReadChunk;
+            }
+            return readable.read();
+        }
+    };
+}
+function consumeStream(stream, reducer) {
+    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);
+                    }
+                }
+            });
+        })
+    );
+}
+function listenStream(stream, listener) {
+    let destroyed = false;
+    stream.on('error', error => {
+        if (!destroyed) {
+            listener.onError(error);
+        }
+    });
+    stream.on('end', () => {
+        if (!destroyed) {
+            listener.onEnd();
+        }
+    });
+    stream.on('data', data => {
+        if (!destroyed) {
+            listener.onData(data);
+        }
+    });
+    return toDisposable(() => destroyed = true);
+}
+function peekStream(stream, maxChunks) {
+    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);
+        })
+    );
+}
+function toReadable(t) {
+    let consumed = false;
+    return {
+        read: () => {
+            if (consumed) {
+                return null;
+            }
+            consumed = true;
+            return t;
+        }
+    };
+}
+function transform(stream, transformer, reducer) {
+    const target = newWriteableStream(reducer);
+    listenStream(stream, {
+        onData: data => target.write(transformer.data(data)),
+        onError: error => target.error(transformer.error ? transformer.error(error) : error),
+        onEnd: () => target.end()
+    });
+    return target;
+}
+const hasBuffer = (typeof Buffer !== 'undefined');
+let textEncoder;
+let textDecoder;
+class VSBuffer {
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.byteLength = this.buffer.byteLength;
+    }
+    static alloc(byteLength) {
+        if (hasBuffer) {
+            return (
+                 new VSBuffer(Buffer.allocUnsafe(byteLength))
+            );
+        }
+        else {
+            return (
+                 new VSBuffer( new Uint8Array(byteLength))
+            );
+        }
+    }
+    static wrap(actual) {
+        if (hasBuffer && !(Buffer.isBuffer(actual))) {
+            actual = Buffer.from(actual.buffer, actual.byteOffset, actual.byteLength);
+        }
+        return (
+             new VSBuffer(actual)
+        );
+    }
+    static fromString(source, options) {
+        const dontUseNodeBuffer = options?.dontUseNodeBuffer || false;
+        if (!dontUseNodeBuffer && hasBuffer) {
+            return (
+                 new VSBuffer(Buffer.from(source))
+            );
+        }
+        else {
+            if (!textEncoder) {
+                textEncoder =  new TextEncoder();
+            }
+            return (
+                 new VSBuffer(textEncoder.encode(source))
+            );
+        }
+    }
+    static fromByteArray(source) {
+        const result = VSBuffer.alloc(source.length);
+        for (let i = 0, len = source.length; i < len; i++) {
+            result.buffer[i] = source[i];
+        }
+        return result;
+    }
+    static concat(buffers, totalLength) {
+        if (typeof totalLength === 'undefined') {
+            totalLength = 0;
+            for (let i = 0, len = buffers.length; i < len; i++) {
+                totalLength += buffers[i].byteLength;
+            }
+        }
+        const ret = VSBuffer.alloc(totalLength);
+        let offset = 0;
+        for (let i = 0, len = buffers.length; i < len; i++) {
+            const element = buffers[i];
+            ret.set(element, offset);
+            offset += element.byteLength;
+        }
+        return ret;
+    }
+    clone() {
+        const result = VSBuffer.alloc(this.byteLength);
+        result.set(this);
+        return result;
+    }
+    toString() {
+        if (hasBuffer) {
+            return this.buffer.toString();
+        }
+        else {
+            if (!textDecoder) {
+                textDecoder =  new TextDecoder();
+            }
+            return textDecoder.decode(this.buffer);
+        }
+    }
+    slice(start, end) {
+        return (
+             new VSBuffer(this.buffer.subarray(start, end))
+        );
+    }
+    set(array, offset) {
+        if (array instanceof VSBuffer) {
+            this.buffer.set(array.buffer, offset);
+        }
+        else if (array instanceof Uint8Array) {
+            this.buffer.set(array, offset);
+        }
+        else if (array instanceof ArrayBuffer) {
+            this.buffer.set( new Uint8Array(array), offset);
+        }
+        else if (ArrayBuffer.isView(array)) {
+            this.buffer.set( new Uint8Array(array.buffer, array.byteOffset, array.byteLength), offset);
+        }
+        else {
+            throw new Error(`Unknown argument 'array'`);
+        }
+    }
+    readUInt32BE(offset) {
+        return readUInt32BE(this.buffer, offset);
+    }
+    writeUInt32BE(value, offset) {
+        writeUInt32BE(this.buffer, value, offset);
+    }
+    readUInt32LE(offset) {
+        return readUInt32LE(this.buffer, offset);
+    }
+    writeUInt32LE(value, offset) {
+        writeUInt32LE(this.buffer, value, offset);
+    }
+    readUInt8(offset) {
+        return readUInt8(this.buffer, offset);
+    }
+    writeUInt8(value, offset) {
+        writeUInt8(this.buffer, value, offset);
+    }
+}
+function readUInt32BE(source, offset) {
+    return (source[offset] * 2 ** 24
+        + source[offset + 1] * 2 ** 16
+        + source[offset + 2] * 2 ** 8
+        + source[offset + 3]);
+}
+function writeUInt32BE(destination, value, offset) {
+    destination[offset + 3] = value;
+    value = value >>> 8;
+    destination[offset + 2] = value;
+    value = value >>> 8;
+    destination[offset + 1] = value;
+    value = value >>> 8;
+    destination[offset] = value;
+}
+function readUInt32LE(source, offset) {
+    return (((source[offset + 0] << 0) >>> 0) |
+        ((source[offset + 1] << 8) >>> 0) |
+        ((source[offset + 2] << 16) >>> 0) |
+        ((source[offset + 3] << 24) >>> 0));
+}
+function writeUInt32LE(destination, value, offset) {
+    destination[offset + 0] = (value & 0b11111111);
+    value = value >>> 8;
+    destination[offset + 1] = (value & 0b11111111);
+    value = value >>> 8;
+    destination[offset + 2] = (value & 0b11111111);
+    value = value >>> 8;
+    destination[offset + 3] = (value & 0b11111111);
+}
+function readUInt8(source, offset) {
+    return source[offset];
+}
+function writeUInt8(destination, value, offset) {
+    destination[offset] = value;
+}
+function readableToBuffer(readable) {
+    return consumeReadable(readable, chunks => VSBuffer.concat(chunks));
+}
+function bufferToReadable(buffer) {
+    return toReadable(buffer);
+}
+function streamToBuffer(stream) {
+    return consumeStream(stream, chunks => VSBuffer.concat(chunks));
+}
+async function bufferedStreamToBuffer(bufferedStream) {
+    if (bufferedStream.ended) {
+        return VSBuffer.concat(bufferedStream.buffer);
+    }
+    return VSBuffer.concat([
+        ...bufferedStream.buffer,
+        await streamToBuffer(bufferedStream.stream)
+    ]);
+}
+function newWriteableBufferStream(options) {
+    return newWriteableStream(chunks => VSBuffer.concat(chunks), options);
+}
+const Emitter = monaco.Emitter;
+class Themable extends Disposable {
+    constructor(themeService) {
+        super();
+        this.themeService = themeService;
+        this.theme = themeService.getColorTheme();
+        this._register(this.themeService.onDidColorThemeChange(theme => this.onThemeChange(theme)));
+    }
+    onThemeChange(theme) {
+        this.theme = theme;
+        this.updateStyles();
+    }
+    updateStyles() {
+    }
+    getColor(id, modify) {
+        let color = this.theme.getColor(id);
+        if (color && modify) {
+            color = modify(color, this.theme);
+        }
+        return color ? color.toString() : null;
+    }
+}
+const CSS_DONE = 'done';
+const CSS_ACTIVE = 'active';
+const CSS_INFINITE = 'infinite';
+const CSS_INFINITE_LONG_RUNNING = 'infinite-long-running';
+const CSS_DISCRETE = 'discrete';
+const defaultOpts = {
+    progressBarBackground:  Color.fromHex('#0E70C0')
+};
+class ProgressBar extends Disposable {
+    constructor(container, options) {
+        super();
+        this.options = options || Object.create(null);
+        mixin(this.options, defaultOpts, false);
+        this.workedVal = 0;
+        this.progressBarBackground = this.options.progressBarBackground;
+        this.showDelayedScheduler = this._register( new RunOnceScheduler(() => show(this.element), 0));
+        this.longRunningScheduler = this._register( new RunOnceScheduler(
+            () => this.infiniteLongRunning(),
+            ProgressBar.LONG_RUNNING_INFINITE_THRESHOLD
+        ));
+        this.create(container);
+    }
+    create(container) {
+        this.element = document.createElement('div');
+        this.element.classList.add('monaco-progress-container');
+        this.element.setAttribute('role', 'progressbar');
+        this.element.setAttribute('aria-valuemin', '0');
+        container.appendChild(this.element);
+        this.bit = document.createElement('div');
+        this.bit.classList.add('progress-bit');
+        this.element.appendChild(this.bit);
+        this.applyStyles();
+    }
+    off() {
+        this.bit.style.width = 'inherit';
+        this.bit.style.opacity = '1';
+        this.element.classList.remove(CSS_ACTIVE, CSS_INFINITE, CSS_INFINITE_LONG_RUNNING, CSS_DISCRETE);
+        this.workedVal = 0;
+        this.totalWork = undefined;
+        this.longRunningScheduler.cancel();
+    }
+    done() {
+        return this.doDone(true);
+    }
+    stop() {
+        return this.doDone(false);
+    }
+    doDone(delayed) {
+        this.element.classList.add(CSS_DONE);
+        if (!this.element.classList.contains(CSS_INFINITE)) {
+            this.bit.style.width = 'inherit';
+            if (delayed) {
+                setTimeout(() => this.off(), 200);
+            }
+            else {
+                this.off();
+            }
+        }
+        else {
+            this.bit.style.opacity = '0';
+            if (delayed) {
+                setTimeout(() => this.off(), 200);
+            }
+            else {
+                this.off();
+            }
+        }
+        return this;
+    }
+    infinite() {
+        this.bit.style.width = '2%';
+        this.bit.style.opacity = '1';
+        this.element.classList.remove(CSS_DISCRETE, CSS_DONE, CSS_INFINITE_LONG_RUNNING);
+        this.element.classList.add(CSS_ACTIVE, CSS_INFINITE);
+        this.longRunningScheduler.schedule();
+        return this;
+    }
+    infiniteLongRunning() {
+        this.element.classList.add(CSS_INFINITE_LONG_RUNNING);
+    }
+    total(value) {
+        this.workedVal = 0;
+        this.totalWork = value;
+        this.element.setAttribute('aria-valuemax', value.toString());
+        return this;
+    }
+    hasTotal() {
+        return isNumber(this.totalWork);
+    }
+    worked(value) {
+        value = Math.max(1, Number(value));
+        return this.doSetWorked(this.workedVal + value);
+    }
+    setWorked(value) {
+        value = Math.max(1, Number(value));
+        return this.doSetWorked(value);
+    }
+    doSetWorked(value) {
+        const totalWork = this.totalWork || 100;
+        this.workedVal = value;
+        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', value.toString());
+        this.bit.style.width = 100 * (this.workedVal / (totalWork)) + '%';
+        return this;
+    }
+    getContainer() {
+        return this.element;
+    }
+    show(delay) {
+        this.showDelayedScheduler.cancel();
+        if (typeof delay === 'number') {
+            this.showDelayedScheduler.schedule(delay);
+        }
+        else {
+            show(this.element);
+        }
+    }
+    hide() {
+        hide(this.element);
+        this.showDelayedScheduler.cancel();
+    }
+    style(styles) {
+        this.progressBarBackground = styles.progressBarBackground;
+        this.applyStyles();
+    }
+    applyStyles() {
+        if (this.bit) {
+            const background = this.progressBarBackground ? this.progressBarBackground.toString() : '';
+            this.bit.style.backgroundColor = background;
+        }
+    }
+}
+ProgressBar.LONG_RUNNING_INFINITE_THRESHOLD = 10000;
+class LanguageService extends Disposable {
+    constructor(warnOnOverwrite = false) {
+        super();
+        this._onDidEncounterLanguage = this._register( new Emitter());
+        this.onDidEncounterLanguage = this._onDidEncounterLanguage.event;
+        this._onDidChange = this._register( new Emitter(
+            { leakWarningThreshold: 200  }
+        ));
+        this.onDidChange = this._onDidChange.event;
+        LanguageService.instanceCount++;
+        this._encounteredLanguages =  new Set();
+        this._registry = this._register( new LanguagesRegistry(true, warnOnOverwrite));
+        this.languageIdCodec = this._registry.languageIdCodec;
+        this._register(this._registry.onDidChange(() => this._onDidChange.fire()));
+    }
+    dispose() {
+        LanguageService.instanceCount--;
+        super.dispose();
+    }
+    isRegisteredLanguageId(languageId) {
+        return this._registry.isRegisteredLanguageId(languageId);
+    }
+    getRegisteredLanguageIds() {
+        return this._registry.getRegisteredLanguageIds();
+    }
+    getSortedRegisteredLanguageNames() {
+        return this._registry.getSortedRegisteredLanguageNames();
+    }
+    getLanguageName(languageId) {
+        return this._registry.getLanguageName(languageId);
+    }
+    getMimeType(languageId) {
+        return this._registry.getMimeType(languageId);
+    }
+    getIcon(languageId) {
+        return this._registry.getIcon(languageId);
+    }
+    getExtensions(languageId) {
+        return this._registry.getExtensions(languageId);
+    }
+    getFilenames(languageId) {
+        return this._registry.getFilenames(languageId);
+    }
+    getConfigurationFiles(languageId) {
+        return this._registry.getConfigurationFiles(languageId);
+    }
+    getLanguageIdByLanguageName(languageName) {
+        return this._registry.getLanguageIdByLanguageName(languageName);
+    }
+    getLanguageIdByMimeType(mimeType) {
+        return this._registry.getLanguageIdByMimeType(mimeType);
+    }
+    guessLanguageIdByFilepathOrFirstLine(resource, firstLine) {
+        const languageIds = this._registry.guessLanguageIdByFilepathOrFirstLine(resource, firstLine);
+        return firstOrDefault(languageIds, null);
+    }
+    createById(languageId) {
+        return (
+             new LanguageSelection(this.onDidChange, () => {
+                return this._createAndGetLanguageIdentifier(languageId);
+            })
+        );
+    }
+    createByMimeType(mimeType) {
+        return (
+             new LanguageSelection(this.onDidChange, () => {
+                const languageId = this.getLanguageIdByMimeType(mimeType);
+                return this._createAndGetLanguageIdentifier(languageId);
+            })
+        );
+    }
+    createByFilepathOrFirstLine(resource, firstLine) {
+        return (
+             new LanguageSelection(this.onDidChange, () => {
+                const languageId = this.guessLanguageIdByFilepathOrFirstLine(resource, firstLine);
+                return this._createAndGetLanguageIdentifier(languageId);
+            })
+        );
+    }
+    _createAndGetLanguageIdentifier(languageId) {
+        if (!languageId || !this.isRegisteredLanguageId(languageId)) {
+            languageId = PLAINTEXT_LANGUAGE_ID;
+        }
+        if (!this._encounteredLanguages.has(languageId)) {
+            this._encounteredLanguages.add(languageId);
+            TokenizationRegistry.getOrCreate(languageId);
+            this._onDidEncounterLanguage.fire(languageId);
+        }
+        return languageId;
+    }
+}
+LanguageService.instanceCount = 0;
+class LanguageSelection {
+    constructor(_onDidChangeLanguages, _selector) {
+        this._onDidChangeLanguages = _onDidChangeLanguages;
+        this._selector = _selector;
+        this._listener = null;
+        this._emitter = null;
+        this.languageId = this._selector();
+    }
+    _dispose() {
+        if (this._listener) {
+            this._listener.dispose();
+            this._listener = null;
+        }
+        if (this._emitter) {
+            this._emitter.dispose();
+            this._emitter = null;
+        }
+    }
+    get onDidChange() {
+        if (!this._listener) {
+            this._listener = this._onDidChangeLanguages(() => this._evaluate());
+        }
+        if (!this._emitter) {
+            this._emitter =  new Emitter({
+                onLastListenerRemove: () => {
+                    this._dispose();
+                }
+            });
+        }
+        return this._emitter.event;
+    }
+    _evaluate() {
+        const languageId = this._selector();
+        if (languageId === this.languageId) {
+            return;
+        }
+        this.languageId = languageId;
+        if (this._emitter) {
+            this._emitter.fire(this.languageId);
+        }
+    }
+}
+class StringIterator {
+    constructor() {
+        this._value = '';
+        this._pos = 0;
+    }
+    reset(key) {
+        this._value = key;
+        this._pos = 0;
+        return this;
+    }
+    next() {
+        this._pos += 1;
+        return this;
+    }
+    hasNext() {
+        return this._pos < this._value.length - 1;
+    }
+    cmp(a) {
+        const aCode = a.charCodeAt(0);
+        const thisCode = this._value.charCodeAt(this._pos);
+        return aCode - thisCode;
+    }
+    value() {
+        return this._value[this._pos];
+    }
+}
+class ConfigKeysIterator {
+    constructor(_caseSensitive = true) {
+        this._caseSensitive = _caseSensitive;
+    }
+    reset(key) {
+        this._value = key;
+        this._from = 0;
+        this._to = 0;
+        return this.next();
+    }
+    hasNext() {
+        return this._to < this._value.length;
+    }
+    next() {
+        this._from = this._to;
+        let justSeps = true;
+        for (; this._to < this._value.length; this._to++) {
+            const ch = this._value.charCodeAt(this._to);
+            if (ch === 46 ) {
+                if (justSeps) {
+                    this._from++;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                justSeps = false;
+            }
+        }
+        return this;
+    }
+    cmp(a) {
+        return this._caseSensitive
+            ? compareSubstring(a, this._value, 0, a.length, this._from, this._to)
+            : compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);
+    }
+    value() {
+        return this._value.substring(this._from, this._to);
+    }
+}
+class PathIterator {
+    constructor(_splitOnBackslash = true, _caseSensitive = true) {
+        this._splitOnBackslash = _splitOnBackslash;
+        this._caseSensitive = _caseSensitive;
+    }
+    reset(key) {
+        this._from = 0;
+        this._to = 0;
+        this._value = key;
+        this._valueLen = key.length;
+        for (let pos = key.length - 1; pos >= 0; pos--, this._valueLen--) {
+            const ch = this._value.charCodeAt(pos);
+            if (!((ch === 47  || this._splitOnBackslash && ch === 92) )) {
+                break;
+            }
+        }
+        return this.next();
+    }
+    hasNext() {
+        return this._to < this._valueLen;
+    }
+    next() {
+        this._from = this._to;
+        let justSeps = true;
+        for (; this._to < this._valueLen; this._to++) {
+            const ch = this._value.charCodeAt(this._to);
+            if (ch === 47  || this._splitOnBackslash && ch === 92 ) {
+                if (justSeps) {
+                    this._from++;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                justSeps = false;
+            }
+        }
+        return this;
+    }
+    cmp(a) {
+        return this._caseSensitive
+            ? compareSubstring(a, this._value, 0, a.length, this._from, this._to)
+            : compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);
+    }
+    value() {
+        return this._value.substring(this._from, this._to);
+    }
+}
+class UriIterator {
+    constructor(_ignorePathCasing) {
+        this._ignorePathCasing = _ignorePathCasing;
+        this._states = [];
+        this._stateIdx = 0;
+    }
+    reset(key) {
+        this._value = key;
+        this._states = [];
+        if (this._value.scheme) {
+            this._states.push(1 );
+        }
+        if (this._value.authority) {
+            this._states.push(2 );
+        }
+        if (this._value.path) {
+            this._pathIterator =  new PathIterator(false, !this._ignorePathCasing(key));
+            this._pathIterator.reset(key.path);
+            if (this._pathIterator.value()) {
+                this._states.push(3 );
+            }
+        }
+        if (this._value.query) {
+            this._states.push(4 );
+        }
+        if (this._value.fragment) {
+            this._states.push(5 );
+        }
+        this._stateIdx = 0;
+        return this;
+    }
+    next() {
+        if (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext()) {
+            this._pathIterator.next();
+        }
+        else {
+            this._stateIdx += 1;
+        }
+        return this;
+    }
+    hasNext() {
+        return (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext())
+            || this._stateIdx < this._states.length - 1;
+    }
+    cmp(a) {
+        if (this._states[this._stateIdx] === 1 ) {
+            return compareIgnoreCase(a, this._value.scheme);
+        }
+        else if (this._states[this._stateIdx] === 2 ) {
+            return compareIgnoreCase(a, this._value.authority);
+        }
+        else if (this._states[this._stateIdx] === 3 ) {
+            return this._pathIterator.cmp(a);
+        }
+        else if (this._states[this._stateIdx] === 4 ) {
+            return compare$1(a, this._value.query);
+        }
+        else if (this._states[this._stateIdx] === 5 ) {
+            return compare$1(a, this._value.fragment);
+        }
+        throw new Error();
+    }
+    value() {
+        if (this._states[this._stateIdx] === 1 ) {
+            return this._value.scheme;
+        }
+        else if (this._states[this._stateIdx] === 2 ) {
+            return this._value.authority;
+        }
+        else if (this._states[this._stateIdx] === 3 ) {
+            return this._pathIterator.value();
+        }
+        else if (this._states[this._stateIdx] === 4 ) {
+            return this._value.query;
+        }
+        else if (this._states[this._stateIdx] === 5 ) {
+            return this._value.fragment;
+        }
+        throw new Error();
+    }
+}
+class TernarySearchTreeNode {
+    constructor() {
+        this.height = 1;
+    }
+    isEmpty() {
+        return !this.left && !this.mid && !this.right && !this.value;
+    }
+    rotateLeft() {
+        const tmp = this.right;
+        this.right = tmp.left;
+        tmp.left = this;
+        this.updateHeight();
+        tmp.updateHeight();
+        return tmp;
+    }
+    rotateRight() {
+        const tmp = this.left;
+        this.left = tmp.right;
+        tmp.right = this;
+        this.updateHeight();
+        tmp.updateHeight();
+        return tmp;
+    }
+    updateHeight() {
+        this.height = 1 + Math.max(this.heightLeft, this.heightRight);
+    }
+    balanceFactor() {
+        return this.heightRight - this.heightLeft;
+    }
+    get heightLeft() {
+        return this.left?.height ?? 0;
+    }
+    get heightRight() {
+        return this.right?.height ?? 0;
+    }
+}
+class TernarySearchTree {
+    constructor(segments) {
+        this._iter = segments;
+    }
+    static forUris(ignorePathCasing = () => false) {
+        return (
+             new TernarySearchTree( new UriIterator(ignorePathCasing))
+        );
+    }
+    static forPaths(ignorePathCasing = false) {
+        return (
+             new TernarySearchTree( new PathIterator(undefined, !ignorePathCasing))
+        );
+    }
+    static forStrings() {
+        return (
+             new TernarySearchTree( new StringIterator())
+        );
+    }
+    static forConfigKeys() {
+        return (
+             new TernarySearchTree( new ConfigKeysIterator())
+        );
+    }
+    clear() {
+        this._root = undefined;
+    }
+    fill(values, keys) {
+        if (keys) {
+            const arr = keys.slice(0);
+            shuffle(arr);
+            for (let k of arr) {
+                this.set(k, values);
+            }
+        }
+        else {
+            const arr = values.slice(0);
+            shuffle(arr);
+            for (let entry of arr) {
+                this.set(entry[0], entry[1]);
+            }
+        }
+    }
+    set(key, element) {
+        const iter = this._iter.reset(key);
+        let node;
+        if (!this._root) {
+            this._root =  new TernarySearchTreeNode();
+            this._root.segment = iter.value();
+        }
+        const stack = [];
+        node = this._root;
+        while (true) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                if (!node.left) {
+                    node.left =  new TernarySearchTreeNode();
+                    node.left.segment = iter.value();
+                }
+                stack.push([-1 , node]);
+                node = node.left;
+            }
+            else if (val < 0) {
+                if (!node.right) {
+                    node.right =  new TernarySearchTreeNode();
+                    node.right.segment = iter.value();
+                }
+                stack.push([1 , node]);
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                if (!node.mid) {
+                    node.mid =  new TernarySearchTreeNode();
+                    node.mid.segment = iter.value();
+                }
+                stack.push([0 , node]);
+                node = node.mid;
+            }
+            else {
+                break;
+            }
+        }
+        const oldElement = node.value;
+        node.value = element;
+        node.key = key;
+        for (let i = stack.length - 1; i >= 0; i--) {
+            const node = stack[i][1];
+            node.updateHeight();
+            const bf = node.balanceFactor();
+            if (bf < -1 || bf > 1) {
+                const d1 = stack[i][0];
+                const d2 = stack[i + 1][0];
+                if (d1 === 1  && d2 === 1 ) {
+                    stack[i][1] = node.rotateLeft();
+                }
+                else if (d1 === -1  && d2 === -1 ) {
+                    stack[i][1] = node.rotateRight();
+                }
+                else if (d1 === 1  && d2 === -1 ) {
+                    node.right = stack[i + 1][1] = stack[i + 1][1].rotateRight();
+                    stack[i][1] = node.rotateLeft();
+                }
+                else if (d1 === -1  && d2 === 1 ) {
+                    node.left = stack[i + 1][1] = stack[i + 1][1].rotateLeft();
+                    stack[i][1] = node.rotateRight();
+                }
+                else {
+                    throw new Error();
+                }
+                if (i > 0) {
+                    switch (stack[i - 1][0]) {
+                        case -1 :
+                            stack[i - 1][1].left = stack[i][1];
+                            break;
+                        case 1 :
+                            stack[i - 1][1].right = stack[i][1];
+                            break;
+                        case 0 :
+                            stack[i - 1][1].mid = stack[i][1];
+                            break;
+                    }
+                }
+                else {
+                    this._root = stack[0][1];
+                }
+            }
+        }
+        return oldElement;
+    }
+    get(key) {
+        return this._getNode(key)?.value;
+    }
+    _getNode(key) {
+        const iter = this._iter.reset(key);
+        let node = this._root;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                node = node.left;
+            }
+            else if (val < 0) {
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                node = node.mid;
+            }
+            else {
+                break;
+            }
+        }
+        return node;
+    }
+    has(key) {
+        const node = this._getNode(key);
+        return !(node?.value === undefined && node?.mid === undefined);
+    }
+    delete(key) {
+        return this._delete(key, false);
+    }
+    deleteSuperstr(key) {
+        return this._delete(key, true);
+    }
+    _delete(key, superStr) {
+        const iter = this._iter.reset(key);
+        const stack = [];
+        let node = this._root;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                stack.push([-1 , node]);
+                node = node.left;
+            }
+            else if (val < 0) {
+                stack.push([1 , node]);
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                stack.push([0 , node]);
+                node = node.mid;
+            }
+            else {
+                break;
+            }
+        }
+        if (!node) {
+            return;
+        }
+        if (superStr) {
+            node.left = undefined;
+            node.mid = undefined;
+            node.right = undefined;
+            node.height = 1;
+        }
+        else {
+            node.key = undefined;
+            node.value = undefined;
+        }
+        if (!node.mid && !node.value) {
+            if (node.left && node.right) {
+                const min = this._min(node.right);
+                const { key, value, segment } = min;
+                this._delete(min.key, false);
+                node.key = key;
+                node.value = value;
+                node.segment = segment;
+            }
+            else {
+                const newChild = node.left ?? node.right;
+                if (stack.length > 0) {
+                    const [dir, parent] = stack[stack.length - 1];
+                    switch (dir) {
+                        case -1 :
+                            parent.left = newChild;
+                            break;
+                        case 0 :
+                            parent.mid = newChild;
+                            break;
+                        case 1 :
+                            parent.right = newChild;
+                            break;
+                    }
+                }
+                else {
+                    this._root = newChild;
+                }
+            }
+        }
+        for (let i = stack.length - 1; i >= 0; i--) {
+            const node = stack[i][1];
+            node.updateHeight();
+            const bf = node.balanceFactor();
+            if (bf > 1) {
+                if (node.right.balanceFactor() >= 0) {
+                    stack[i][1] = node.rotateLeft();
+                }
+                else {
+                    node.right = node.right.rotateRight();
+                    stack[i][1] = node.rotateLeft();
+                }
+            }
+            else if (bf < -1) {
+                if (node.left.balanceFactor() <= 0) {
+                    stack[i][1] = node.rotateRight();
+                }
+                else {
+                    node.left = node.left.rotateLeft();
+                    stack[i][1] = node.rotateRight();
+                }
+            }
+            if (i > 0) {
+                switch (stack[i - 1][0]) {
+                    case -1 :
+                        stack[i - 1][1].left = stack[i][1];
+                        break;
+                    case 1 :
+                        stack[i - 1][1].right = stack[i][1];
+                        break;
+                    case 0 :
+                        stack[i - 1][1].mid = stack[i][1];
+                        break;
+                }
+            }
+            else {
+                this._root = stack[0][1];
+            }
+        }
+    }
+    _min(node) {
+        while (node.left) {
+            node = node.left;
+        }
+        return node;
+    }
+    findSubstr(key) {
+        const iter = this._iter.reset(key);
+        let node = this._root;
+        let candidate = undefined;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                node = node.left;
+            }
+            else if (val < 0) {
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                candidate = node.value || candidate;
+                node = node.mid;
+            }
+            else {
+                break;
+            }
+        }
+        return node && node.value || candidate;
+    }
+    findSuperstr(key) {
+        const iter = this._iter.reset(key);
+        let node = this._root;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                node = node.left;
+            }
+            else if (val < 0) {
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                node = node.mid;
+            }
+            else {
+                if (!node.mid) {
+                    return undefined;
+                }
+                else {
+                    return this._entries(node.mid);
+                }
+            }
+        }
+        return undefined;
+    }
+    forEach(callback) {
+        for (const [key, value] of this) {
+            callback(value, key);
+        }
+    }
+    *[Symbol.iterator]() {
+        yield* this._entries(this._root);
+    }
+    *_entries(node) {
+        if (!node) {
+            return;
+        }
+        if (node.left) {
+            yield* this._entries(node.left);
+        }
+        if (node.value) {
+            yield [node.key, node.value];
+        }
+        if (node.mid) {
+            yield* this._entries(node.mid);
+        }
+        if (node.right) {
+            yield* this._entries(node.right);
+        }
+    }
+    _isBalanced() {
+        const nodeIsBalanced = (node) => {
+            if (!node) {
+                return true;
+            }
+            const bf = node.balanceFactor();
+            if (bf < -1 || bf > 1) {
+                return false;
+            }
+            return nodeIsBalanced(node.left) && nodeIsBalanced(node.right);
+        };
+        return nodeIsBalanced(this._root);
+    }
+}
+var ParseOptions;
+ (function(ParseOptions) {
+    ParseOptions.DEFAULT = {
+        allowTrailingComma: true
+    };
+})(ParseOptions || (ParseOptions = {}));
+function createScanner(text, ignoreTrivia = false) {
+    let pos = 0, len = text.length, value = '', tokenOffset = 0, token = 16 , scanError = 0 ;
+    function scanHexDigits(count) {
+        let digits = 0;
+        let hexValue = 0;
+        while (digits < count) {
+            const ch = text.charCodeAt(pos);
+            if (ch >= 48  && ch <= 57 ) {
+                hexValue = hexValue * 16 + ch - 48 ;
+            }
+            else if (ch >= 65  && ch <= 70 ) {
+                hexValue = hexValue * 16 + ch - 65  + 10;
+            }
+            else if (ch >= 97  && ch <= 102 ) {
+                hexValue = hexValue * 16 + ch - 97  + 10;
+            }
+            else {
+                break;
+            }
+            pos++;
+            digits++;
+        }
+        if (digits < count) {
+            hexValue = -1;
+        }
+        return hexValue;
+    }
+    function setPosition(newPosition) {
+        pos = newPosition;
+        value = '';
+        tokenOffset = 0;
+        token = 16 ;
+        scanError = 0 ;
+    }
+    function scanNumber() {
+        const start = pos;
+        if (text.charCodeAt(pos) === 48 ) {
+            pos++;
+        }
+        else {
+            pos++;
+            while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+                pos++;
+            }
+        }
+        if (pos < text.length && text.charCodeAt(pos) === 46 ) {
+            pos++;
+            if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+                pos++;
+                while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+                    pos++;
+                }
+            }
+            else {
+                scanError = 3 ;
+                return text.substring(start, pos);
+            }
+        }
+        let end = pos;
+        if (pos < text.length && ((text.charCodeAt(pos) === 69  || text.charCodeAt(pos) === 101) )) {
+            pos++;
+            if (pos < text.length && text.charCodeAt(pos) === 43  || text.charCodeAt(pos) === 45 ) {
+                pos++;
+            }
+            if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+                pos++;
+                while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+                    pos++;
+                }
+                end = pos;
+            }
+            else {
+                scanError = 3 ;
+            }
+        }
+        return text.substring(start, end);
+    }
+    function scanString() {
+        let result = '', start = pos;
+        while (true) {
+            if (pos >= len) {
+                result += text.substring(start, pos);
+                scanError = 2 ;
+                break;
+            }
+            const ch = text.charCodeAt(pos);
+            if (ch === 34 ) {
+                result += text.substring(start, pos);
+                pos++;
+                break;
+            }
+            if (ch === 92 ) {
+                result += text.substring(start, pos);
+                pos++;
+                if (pos >= len) {
+                    scanError = 2 ;
+                    break;
+                }
+                const ch2 = text.charCodeAt(pos++);
+                switch (ch2) {
+                    case 34 :
+                        result += '\"';
+                        break;
+                    case 92 :
+                        result += '\\';
+                        break;
+                    case 47 :
+                        result += '/';
+                        break;
+                    case 98 :
+                        result += '\b';
+                        break;
+                    case 102 :
+                        result += '\f';
+                        break;
+                    case 110 :
+                        result += '\n';
+                        break;
+                    case 114 :
+                        result += '\r';
+                        break;
+                    case 116 :
+                        result += '\t';
+                        break;
+                    case 117 : {
+                        const ch3 = scanHexDigits(4);
+                        if (ch3 >= 0) {
+                            result += String.fromCharCode(ch3);
+                        }
+                        else {
+                            scanError = 4 ;
+                        }
+                        break;
+                    }
+                    default:
+                        scanError = 5 ;
+                }
+                start = pos;
+                continue;
+            }
+            if (ch >= 0 && ch <= 0x1F) {
+                if (isLineBreak(ch)) {
+                    result += text.substring(start, pos);
+                    scanError = 2 ;
+                    break;
+                }
+                else {
+                    scanError = 6 ;
+                }
+            }
+            pos++;
+        }
+        return result;
+    }
+    function scanNext() {
+        value = '';
+        scanError = 0 ;
+        tokenOffset = pos;
+        if (pos >= len) {
+            tokenOffset = len;
+            return token = 17 ;
+        }
+        let code = text.charCodeAt(pos);
+        if (isWhitespace(code)) {
+            do {
+                pos++;
+                value += String.fromCharCode(code);
+                code = text.charCodeAt(pos);
+            } while (isWhitespace(code));
+            return token = 15 ;
+        }
+        if (isLineBreak(code)) {
+            pos++;
+            value += String.fromCharCode(code);
+            if (code === 13  && text.charCodeAt(pos) === 10 ) {
+                pos++;
+                value += '\n';
+            }
+            return token = 14 ;
+        }
+        switch (code) {
+            case 123 :
+                pos++;
+                return token = 1 ;
+            case 125 :
+                pos++;
+                return token = 2 ;
+            case 91 :
+                pos++;
+                return token = 3 ;
+            case 93 :
+                pos++;
+                return token = 4 ;
+            case 58 :
+                pos++;
+                return token = 6 ;
+            case 44 :
+                pos++;
+                return token = 5 ;
+            case 34 :
+                pos++;
+                value = scanString();
+                return token = 10 ;
+            case 47 : {
+                const start = pos - 1;
+                if (text.charCodeAt(pos + 1) === 47 ) {
+                    pos += 2;
+                    while (pos < len) {
+                        if (isLineBreak(text.charCodeAt(pos))) {
+                            break;
+                        }
+                        pos++;
+                    }
+                    value = text.substring(start, pos);
+                    return token = 12 ;
+                }
+                if (text.charCodeAt(pos + 1) === 42 ) {
+                    pos += 2;
+                    const safeLength = len - 1;
+                    let commentClosed = false;
+                    while (pos < safeLength) {
+                        const ch = text.charCodeAt(pos);
+                        if (ch === 42  && text.charCodeAt(pos + 1) === 47 ) {
+                            pos += 2;
+                            commentClosed = true;
+                            break;
+                        }
+                        pos++;
+                    }
+                    if (!commentClosed) {
+                        pos++;
+                        scanError = 1 ;
+                    }
+                    value = text.substring(start, pos);
+                    return token = 13 ;
+                }
+                value += String.fromCharCode(code);
+                pos++;
+                return token = 16 ;
+            }
+            case 45 :
+                value += String.fromCharCode(code);
+                pos++;
+                if (pos === len || !isDigit(text.charCodeAt(pos))) {
+                    return token = 16 ;
+                }
+            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 ;
+            default:
+                while (pos < len && isUnknownContentCharacter(code)) {
+                    pos++;
+                    code = text.charCodeAt(pos);
+                }
+                if (tokenOffset !== pos) {
+                    value = text.substring(tokenOffset, pos);
+                    switch (value) {
+                        case 'true': return token = 8 ;
+                        case 'false': return token = 9 ;
+                        case 'null': return token = 7 ;
+                    }
+                    return token = 16 ;
+                }
+                value += String.fromCharCode(code);
+                pos++;
+                return token = 16 ;
+        }
+    }
+    function isUnknownContentCharacter(code) {
+        if (isWhitespace(code) || isLineBreak(code)) {
+            return false;
+        }
+        switch (code) {
+            case 125 :
+            case 93 :
+            case 123 :
+            case 91 :
+            case 34 :
+            case 58 :
+            case 44 :
+            case 47 :
+                return false;
+        }
+        return true;
+    }
+    function scanNextNonTrivia() {
+        let result;
+        do {
+            result = scanNext();
+        } while (result >= 12  && result <= 15 );
+        return result;
+    }
+    return {
+        setPosition: setPosition,
+        getPosition: () => pos,
+        scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+        getToken: () => token,
+        getTokenValue: () => value,
+        getTokenOffset: () => tokenOffset,
+        getTokenLength: () => pos - tokenOffset,
+        getTokenError: () => scanError
+    };
+}
+function isWhitespace(ch) {
+    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  || ch === 13  || ch === 8232  || ch === 8233 ;
+}
+function isDigit(ch) {
+    return ch >= 48  && ch <= 57 ;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+    const _scanner = createScanner(text, false);
+    function toNoArgVisit(visitFunction) {
+        return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength()) : () => true;
+    }
+    function toOneArgVisit(visitFunction) {
+        return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength()) : () => true;
+    }
+    const onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+    const disallowComments = options && options.disallowComments;
+    const allowTrailingComma = options && options.allowTrailingComma;
+    function scanNext() {
+        while (true) {
+            const token = _scanner.scan();
+            switch (_scanner.getTokenError()) {
+                case 4 :
+                    handleError(14 );
+                    break;
+                case 5 :
+                    handleError(15 );
+                    break;
+                case 3 :
+                    handleError(13 );
+                    break;
+                case 1 :
+                    if (!disallowComments) {
+                        handleError(11 );
+                    }
+                    break;
+                case 2 :
+                    handleError(12 );
+                    break;
+                case 6 :
+                    handleError(16 );
+                    break;
+            }
+            switch (token) {
+                case 12 :
+                case 13 :
+                    if (disallowComments) {
+                        handleError(10 );
+                    }
+                    else {
+                        onComment();
+                    }
+                    break;
+                case 16 :
+                    handleError(1 );
+                    break;
+                case 15 :
+                case 14 :
+                    break;
+                default:
+                    return token;
+            }
+        }
+    }
+    function handleError(error, skipUntilAfter = [], skipUntil = []) {
+        onError(error);
+        if (skipUntilAfter.length + skipUntil.length > 0) {
+            let token = _scanner.getToken();
+            while (token !== 17 ) {
+                if (skipUntilAfter.indexOf(token) !== -1) {
+                    scanNext();
+                    break;
+                }
+                else if (skipUntil.indexOf(token) !== -1) {
+                    break;
+                }
+                token = scanNext();
+            }
+        }
+    }
+    function parseString(isValue) {
+        const value = _scanner.getTokenValue();
+        if (isValue) {
+            onLiteralValue(value);
+        }
+        else {
+            onObjectProperty(value);
+        }
+        scanNext();
+        return true;
+    }
+    function parseLiteral() {
+        switch (_scanner.getToken()) {
+            case 11 : {
+                let value = 0;
+                try {
+                    value = JSON.parse(_scanner.getTokenValue());
+                    if (typeof value !== 'number') {
+                        handleError(2 );
+                        value = 0;
+                    }
+                }
+                catch (e) {
+                    handleError(2 );
+                }
+                onLiteralValue(value);
+                break;
+            }
+            case 7 :
+                onLiteralValue(null);
+                break;
+            case 8 :
+                onLiteralValue(true);
+                break;
+            case 9 :
+                onLiteralValue(false);
+                break;
+            default:
+                return false;
+        }
+        scanNext();
+        return true;
+    }
+    function parseProperty() {
+        if (_scanner.getToken() !== 10 ) {
+            handleError(3 , [], [2 , 5 ]);
+            return false;
+        }
+        parseString(false);
+        if (_scanner.getToken() === 6 ) {
+            onSeparator(':');
+            scanNext();
+            if (!parseValue()) {
+                handleError(4 , [], [2 , 5 ]);
+            }
+        }
+        else {
+            handleError(5 , [], [2 , 5 ]);
+        }
+        return true;
+    }
+    function parseObject() {
+        onObjectBegin();
+        scanNext();
+        let needsComma = false;
+        while (_scanner.getToken() !== 2  && _scanner.getToken() !== 17 ) {
+            if (_scanner.getToken() === 5 ) {
+                if (!needsComma) {
+                    handleError(4 , [], []);
+                }
+                onSeparator(',');
+                scanNext();
+                if (_scanner.getToken() === 2  && allowTrailingComma) {
+                    break;
+                }
+            }
+            else if (needsComma) {
+                handleError(6 , [], []);
+            }
+            if (!parseProperty()) {
+                handleError(4 , [], [2 , 5 ]);
+            }
+            needsComma = true;
+        }
+        onObjectEnd();
+        if (_scanner.getToken() !== 2 ) {
+            handleError(7 , [2 ], []);
+        }
+        else {
+            scanNext();
+        }
+        return true;
+    }
+    function parseArray() {
+        onArrayBegin();
+        scanNext();
+        let needsComma = false;
+        while (_scanner.getToken() !== 4  && _scanner.getToken() !== 17 ) {
+            if (_scanner.getToken() === 5 ) {
+                if (!needsComma) {
+                    handleError(4 , [], []);
+                }
+                onSeparator(',');
+                scanNext();
+                if (_scanner.getToken() === 4  && allowTrailingComma) {
+                    break;
+                }
+            }
+            else if (needsComma) {
+                handleError(6 , [], []);
+            }
+            if (!parseValue()) {
+                handleError(4 , [], [4 , 5 ]);
+            }
+            needsComma = true;
+        }
+        onArrayEnd();
+        if (_scanner.getToken() !== 4 ) {
+            handleError(8 , [4 ], []);
+        }
+        else {
+            scanNext();
+        }
+        return true;
+    }
+    function parseValue() {
+        switch (_scanner.getToken()) {
+            case 3 :
+                return parseArray();
+            case 1 :
+                return parseObject();
+            case 10 :
+                return parseString(true);
+            default:
+                return parseLiteral();
+        }
+    }
+    scanNext();
+    if (_scanner.getToken() === 17 ) {
+        if (options.allowEmptyContent) {
+            return true;
+        }
+        handleError(4 , [], []);
+        return false;
+    }
+    if (!parseValue()) {
+        handleError(4 , [], []);
+        return false;
+    }
+    if (_scanner.getToken() !== 17 ) {
+        handleError(9 , [], []);
+    }
+    return true;
+}
+class ConfigurationModel {
+    constructor(_contents = {}, _keys = [], _overrides = []) {
+        this._contents = _contents;
+        this._keys = _keys;
+        this._overrides = _overrides;
+        this.isFrozen = false;
+        this.overrideConfigurations =  new Map();
+    }
+    get contents() {
+        return this.checkAndFreeze(this._contents);
+    }
+    get overrides() {
+        return this.checkAndFreeze(this._overrides);
+    }
+    get keys() {
+        return this.checkAndFreeze(this._keys);
+    }
+    isEmpty() {
+        return this._keys.length === 0 && Object.keys(this._contents).length === 0 && this._overrides.length === 0;
+    }
+    getValue(section) {
+        return section ? getConfigurationValue(this.contents, section) : this.contents;
+    }
+    getOverrideValue(section, overrideIdentifier) {
+        const overrideContents = this.getContentsForOverrideIdentifer(overrideIdentifier);
+        return overrideContents
+            ? section ? getConfigurationValue(overrideContents, section) : overrideContents
+            : undefined;
+    }
+    getKeysForOverrideIdentifier(identifier) {
+        const keys = [];
+        for (const override of this.overrides) {
+            if (override.identifiers.includes(identifier)) {
+                keys.push(...override.keys);
+            }
+        }
+        return distinct(keys);
+    }
+    getAllOverrideIdentifiers() {
+        const result = [];
+        for (const override of this.overrides) {
+            result.push(...override.identifiers);
+        }
+        return distinct(result);
+    }
+    override(identifier) {
+        let overrideConfigurationModel = this.overrideConfigurations.get(identifier);
+        if (!overrideConfigurationModel) {
+            overrideConfigurationModel = this.createOverrideConfigurationModel(identifier);
+            this.overrideConfigurations.set(identifier, overrideConfigurationModel);
+        }
+        return overrideConfigurationModel;
+    }
+    merge(...others) {
+        const contents = deepClone(this.contents);
+        const overrides = deepClone(this.overrides);
+        const keys = [...this.keys];
+        for (const other of others) {
+            this.mergeContents(contents, other.contents);
+            for (const otherOverride of other.overrides) {
+                const [override] = overrides.filter(o => equals$1(o.identifiers, otherOverride.identifiers));
+                if (override) {
+                    this.mergeContents(override.contents, otherOverride.contents);
+                    override.keys.push(...otherOverride.keys);
+                    override.keys = distinct(override.keys);
+                }
+                else {
+                    overrides.push(deepClone(otherOverride));
+                }
+            }
+            for (const key of other.keys) {
+                if (keys.indexOf(key) === -1) {
+                    keys.push(key);
+                }
+            }
+        }
+        return (
+             new ConfigurationModel(contents, keys, overrides)
+        );
+    }
+    freeze() {
+        this.isFrozen = true;
+        return this;
+    }
+    createOverrideConfigurationModel(identifier) {
+        const overrideContents = this.getContentsForOverrideIdentifer(identifier);
+        if (!overrideContents || typeof overrideContents !== 'object' || !Object.keys(overrideContents).length) {
+            return this;
+        }
+        let contents = {};
+        for (const key of distinct([...Object.keys(this.contents), ...Object.keys(overrideContents)])) {
+            let contentsForKey = this.contents[key];
+            let overrideContentsForKey = overrideContents[key];
+            if (overrideContentsForKey) {
+                if (typeof contentsForKey === 'object' && typeof overrideContentsForKey === 'object') {
+                    contentsForKey = deepClone(contentsForKey);
+                    this.mergeContents(contentsForKey, overrideContentsForKey);
+                }
+                else {
+                    contentsForKey = overrideContentsForKey;
+                }
+            }
+            contents[key] = contentsForKey;
+        }
+        return (
+             new ConfigurationModel(contents, this.keys, this.overrides)
+        );
+    }
+    mergeContents(source, target) {
+        for (const key of Object.keys(target)) {
+            if (key in source) {
+                if (isObject(source[key]) && isObject(target[key])) {
+                    this.mergeContents(source[key], target[key]);
+                    continue;
+                }
+            }
+            source[key] = deepClone(target[key]);
+        }
+    }
+    checkAndFreeze(data) {
+        if (this.isFrozen && !Object.isFrozen(data)) {
+            return deepFreeze(data);
+        }
+        return data;
+    }
+    getContentsForOverrideIdentifer(identifier) {
+        let contentsForIdentifierOnly = null;
+        let contents = null;
+        const mergeContents = (contentsToMerge) => {
+            if (contentsToMerge) {
+                if (contents) {
+                    this.mergeContents(contents, contentsToMerge);
+                }
+                else {
+                    contents = deepClone(contentsToMerge);
+                }
+            }
+        };
+        for (const override of this.overrides) {
+            if (equals$1(override.identifiers, [identifier])) {
+                contentsForIdentifierOnly = override.contents;
+            }
+            else if (override.identifiers.includes(identifier)) {
+                mergeContents(override.contents);
+            }
+        }
+        mergeContents(contentsForIdentifierOnly);
+        return contents;
+    }
+    toJSON() {
+        return {
+            contents: this.contents,
+            overrides: this.overrides,
+            keys: this.keys
+        };
+    }
+    setValue(key, value) {
+        this.addKey(key);
+        addToValueTree(this.contents, key, value, e => { throw new Error(e); });
+    }
+    removeValue(key) {
+        if (this.removeKey(key)) {
+            removeFromValueTree(this.contents, key);
+        }
+    }
+    addKey(key) {
+        let index = this.keys.length;
+        for (let i = 0; i < index; i++) {
+            if (key.indexOf(this.keys[i]) === 0) {
+                index = i;
+            }
+        }
+        this.keys.splice(index, 1, key);
+    }
+    removeKey(key) {
+        let index = this.keys.indexOf(key);
+        if (index !== -1) {
+            this.keys.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+}
+class ConfigurationModelParser {
+    constructor(_name) {
+        this._name = _name;
+        this._raw = null;
+        this._configurationModel = null;
+        this._restrictedConfigurations = [];
+        this._parseErrors = [];
+    }
+    get configurationModel() {
+        return this._configurationModel ||  new ConfigurationModel();
+    }
+    get restrictedConfigurations() {
+        return this._restrictedConfigurations;
+    }
+    get errors() {
+        return this._parseErrors;
+    }
+    parse(content, options) {
+        if (!isUndefinedOrNull(content)) {
+            const raw = this.doParseContent(content);
+            this.parseRaw(raw, options);
+        }
+    }
+    reparse(options) {
+        if (this._raw) {
+            this.parseRaw(this._raw, options);
+        }
+    }
+    parseRaw(raw, options) {
+        this._raw = raw;
+        const { contents, keys, overrides, restricted } = this.doParseRaw(raw, options);
+        this._configurationModel =  new ConfigurationModel(contents, keys, overrides);
+        this._restrictedConfigurations = restricted || [];
+    }
+    doParseContent(content) {
+        let raw = {};
+        let currentProperty = null;
+        let currentParent = [];
+        let previousParents = [];
+        function onValue(value) {
+            if (Array.isArray(currentParent)) {
+                currentParent.push(value);
+            }
+            else if (currentProperty !== null) {
+                currentParent[currentProperty] = value;
+            }
+        }
+        let visitor = {
+            onObjectBegin: () => {
+                let object = {};
+                onValue(object);
+                previousParents.push(currentParent);
+                currentParent = object;
+                currentProperty = null;
+            },
+            onObjectProperty: (name) => {
+                currentProperty = name;
+            },
+            onObjectEnd: () => {
+                currentParent = previousParents.pop();
+            },
+            onArrayBegin: () => {
+                let array = [];
+                onValue(array);
+                previousParents.push(currentParent);
+                currentParent = array;
+                currentProperty = null;
+            },
+            onArrayEnd: () => {
+                currentParent = previousParents.pop();
+            },
+            onLiteralValue: onValue,
+            onError: (error, offset, length) => {
+            }
+        };
+        if (content) {
+            try {
+                visit(content, visitor);
+                raw = currentParent[0] || {};
+            }
+            catch (e) {
+                console.error(`Error while parsing settings file ${this._name}: ${e}`);
+                this._parseErrors = [e];
+            }
+        }
+        return raw;
+    }
+    doParseRaw(raw, options) {
+        const configurationProperties =  Registry.as(Extensions.Configuration).getConfigurationProperties();
+        const filtered = this.filter(raw, configurationProperties, true, options);
+        raw = filtered.raw;
+        const contents = toValuesTree(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+        const keys = Object.keys(raw);
+        const overrides = this.toOverrides(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+        return { contents, keys, overrides, restricted: filtered.restricted };
+    }
+    filter(properties, configurationProperties, filterOverriddenProperties, options) {
+        if (!options?.scopes && !options?.skipRestricted) {
+            return { raw: properties, restricted: [] };
+        }
+        const raw = {};
+        const restricted = [];
+        for (let key in properties) {
+            if (OVERRIDE_PROPERTY_REGEX.test(key) && filterOverriddenProperties) {
+                const result = this.filter(properties[key], configurationProperties, false, options);
+                raw[key] = result.raw;
+                restricted.push(...result.restricted);
+            }
+            else {
+                const propertySchema = configurationProperties[key];
+                const scope = propertySchema ? typeof propertySchema.scope !== 'undefined' ? propertySchema.scope : 3  : undefined;
+                if (propertySchema?.restricted) {
+                    restricted.push(key);
+                }
+                if (scope === undefined || options.scopes === undefined || options.scopes.includes(scope)) {
+                    if (!(options.skipRestricted && propertySchema?.restricted)) {
+                        raw[key] = properties[key];
+                    }
+                }
+            }
+        }
+        return { raw, restricted };
+    }
+    toOverrides(raw, conflictReporter) {
+        const overrides = [];
+        for (const key of Object.keys(raw)) {
+            if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+                const overrideRaw = {};
+                for (const keyInOverrideRaw in raw[key]) {
+                    overrideRaw[keyInOverrideRaw] = raw[key][keyInOverrideRaw];
+                }
+                overrides.push({
+                    identifiers: overrideIdentifiersFromKey(key),
+                    keys: Object.keys(overrideRaw),
+                    contents: toValuesTree(overrideRaw, conflictReporter)
+                });
+            }
+        }
+        return overrides;
+    }
+}
+class UserSettings extends Disposable {
+    constructor(userSettingsResource, scopes, extUri, fileService) {
+        super();
+        this.userSettingsResource = userSettingsResource;
+        this.scopes = scopes;
+        this.fileService = fileService;
+        this._onDidChange = this._register( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this.parser =  new ConfigurationModelParser(this.userSettingsResource.toString());
+        this.parseOptions = { scopes: this.scopes };
+        this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
+        this._register(this.fileService.watch(this.userSettingsResource));
+        this._register(Event.any(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.userSettingsResource)), Event.filter(this.fileService.onDidRunOperation, e => (e.isOperation(0 ) || e.isOperation(1 ) || e.isOperation(4 )) && extUri.isEqual(e.resource, userSettingsResource)))(() => this._onDidChange.fire()));
+    }
+    async loadConfiguration() {
+        try {
+            const content = await this.fileService.readFile(this.userSettingsResource);
+            this.parser.parse(content.value.toString() || '{}', this.parseOptions);
+            return this.parser.configurationModel;
+        }
+        catch (e) {
+            return (
+                 new ConfigurationModel()
+            );
+        }
+    }
+    reparse() {
+        this.parser.reparse(this.parseOptions);
+        return this.parser.configurationModel;
+    }
+    getRestrictedSettings() {
+        return this.parser.restrictedConfigurations;
+    }
+}
+class Configuration {
+    constructor(_defaultConfiguration, _localUserConfiguration, _remoteUserConfiguration =  new ConfigurationModel(), _workspaceConfiguration =  new ConfigurationModel(), _folderConfigurations =  new ResourceMap(), _memoryConfiguration =  new ConfigurationModel(), _memoryConfigurationByResource =  new ResourceMap(), _freeze = true) {
+        this._defaultConfiguration = _defaultConfiguration;
+        this._localUserConfiguration = _localUserConfiguration;
+        this._remoteUserConfiguration = _remoteUserConfiguration;
+        this._workspaceConfiguration = _workspaceConfiguration;
+        this._folderConfigurations = _folderConfigurations;
+        this._memoryConfiguration = _memoryConfiguration;
+        this._memoryConfigurationByResource = _memoryConfigurationByResource;
+        this._freeze = _freeze;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations =  new ResourceMap();
+        this._userConfiguration = null;
+    }
+    getValue(section, overrides, workspace) {
+        const consolidateConfigurationModel = this.getConsolidateConfigurationModel(overrides, workspace);
+        return consolidateConfigurationModel.getValue(section);
+    }
+    updateValue(key, value, overrides = {}) {
+        let memoryConfiguration;
+        if (overrides.resource) {
+            memoryConfiguration = this._memoryConfigurationByResource.get(overrides.resource);
+            if (!memoryConfiguration) {
+                memoryConfiguration =  new ConfigurationModel();
+                this._memoryConfigurationByResource.set(overrides.resource, memoryConfiguration);
+            }
+        }
+        else {
+            memoryConfiguration = this._memoryConfiguration;
+        }
+        if (value === undefined) {
+            memoryConfiguration.removeValue(key);
+        }
+        else {
+            memoryConfiguration.setValue(key, value);
+        }
+        if (!overrides.resource) {
+            this._workspaceConsolidatedConfiguration = null;
+        }
+    }
+    inspect(key, overrides, workspace) {
+        const consolidateConfigurationModel = this.getConsolidateConfigurationModel(overrides, workspace);
+        const folderConfigurationModel = this.getFolderConfigurationModelForResource(overrides.resource, workspace);
+        const memoryConfigurationModel = overrides.resource ? this._memoryConfigurationByResource.get(overrides.resource) || this._memoryConfiguration : this._memoryConfiguration;
+        const defaultValue = overrides.overrideIdentifier ? this._defaultConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this._defaultConfiguration.freeze().getValue(key);
+        const userValue = overrides.overrideIdentifier ? this.userConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this.userConfiguration.freeze().getValue(key);
+        const userLocalValue = overrides.overrideIdentifier ? this.localUserConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this.localUserConfiguration.freeze().getValue(key);
+        const userRemoteValue = overrides.overrideIdentifier ? this.remoteUserConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this.remoteUserConfiguration.freeze().getValue(key);
+        const workspaceValue = workspace ? overrides.overrideIdentifier ? this._workspaceConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this._workspaceConfiguration.freeze().getValue(key) : undefined;
+        const workspaceFolderValue = folderConfigurationModel ? overrides.overrideIdentifier ? folderConfigurationModel.freeze().override(overrides.overrideIdentifier).getValue(key) : folderConfigurationModel.freeze().getValue(key) : undefined;
+        const memoryValue = overrides.overrideIdentifier ? memoryConfigurationModel.override(overrides.overrideIdentifier).getValue(key) : memoryConfigurationModel.getValue(key);
+        const value = consolidateConfigurationModel.getValue(key);
+        const overrideIdentifiers = distinct(flatten(consolidateConfigurationModel.overrides.map(override => override.identifiers))).filter(overrideIdentifier => consolidateConfigurationModel.getOverrideValue(key, overrideIdentifier) !== undefined);
+        return {
+            defaultValue: defaultValue,
+            userValue: userValue,
+            userLocalValue: userLocalValue,
+            userRemoteValue: userRemoteValue,
+            workspaceValue: workspaceValue,
+            workspaceFolderValue: workspaceFolderValue,
+            memoryValue: memoryValue,
+            value,
+            default: defaultValue !== undefined ? { value: this._defaultConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this._defaultConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
+            user: userValue !== undefined ? { value: this.userConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this.userConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
+            userLocal: userLocalValue !== undefined ? { value: this.localUserConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this.localUserConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
+            userRemote: userRemoteValue !== undefined ? { value: this.remoteUserConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this.remoteUserConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
+            workspace: workspaceValue !== undefined ? { value: this._workspaceConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this._workspaceConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
+            workspaceFolder: workspaceFolderValue !== undefined ? { value: folderConfigurationModel?.freeze().getValue(key), override: overrides.overrideIdentifier ? folderConfigurationModel?.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
+            memory: memoryValue !== undefined ? { value: memoryConfigurationModel.getValue(key), override: overrides.overrideIdentifier ? memoryConfigurationModel.getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
+            overrideIdentifiers: overrideIdentifiers.length ? overrideIdentifiers : undefined
+        };
+    }
+    keys(workspace) {
+        const folderConfigurationModel = this.getFolderConfigurationModelForResource(undefined, workspace);
+        return {
+            default: this._defaultConfiguration.freeze().keys,
+            user: this.userConfiguration.freeze().keys,
+            workspace: this._workspaceConfiguration.freeze().keys,
+            workspaceFolder: folderConfigurationModel ? folderConfigurationModel.freeze().keys : []
+        };
+    }
+    updateDefaultConfiguration(defaultConfiguration) {
+        this._defaultConfiguration = defaultConfiguration;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations.clear();
+    }
+    updateLocalUserConfiguration(localUserConfiguration) {
+        this._localUserConfiguration = localUserConfiguration;
+        this._userConfiguration = null;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations.clear();
+    }
+    updateRemoteUserConfiguration(remoteUserConfiguration) {
+        this._remoteUserConfiguration = remoteUserConfiguration;
+        this._userConfiguration = null;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations.clear();
+    }
+    updateWorkspaceConfiguration(workspaceConfiguration) {
+        this._workspaceConfiguration = workspaceConfiguration;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations.clear();
+    }
+    updateFolderConfiguration(resource, configuration) {
+        this._folderConfigurations.set(resource, configuration);
+        this._foldersConsolidatedConfigurations.delete(resource);
+    }
+    deleteFolderConfiguration(resource) {
+        this.folderConfigurations.delete(resource);
+        this._foldersConsolidatedConfigurations.delete(resource);
+    }
+    compareAndUpdateDefaultConfiguration(defaults, keys) {
+        const overrides = [];
+        if (!keys) {
+            const { added, updated, removed } = compare(this._defaultConfiguration, defaults);
+            keys = [...added, ...updated, ...removed];
+        }
+        for (const key of keys) {
+            for (const overrideIdentifier of overrideIdentifiersFromKey(key)) {
+                const fromKeys = this._defaultConfiguration.getKeysForOverrideIdentifier(overrideIdentifier);
+                const toKeys = defaults.getKeysForOverrideIdentifier(overrideIdentifier);
+                const keys = [
+                    ...toKeys.filter(key => fromKeys.indexOf(key) === -1),
+                    ...fromKeys.filter(key => toKeys.indexOf(key) === -1),
+                    ...fromKeys.filter(key => !equals(this._defaultConfiguration.override(overrideIdentifier).getValue(key), defaults.override(overrideIdentifier).getValue(key)))
+                ];
+                overrides.push([overrideIdentifier, keys]);
+            }
+        }
+        this.updateDefaultConfiguration(defaults);
+        return { keys, overrides };
+    }
+    compareAndUpdateLocalUserConfiguration(user) {
+        const { added, updated, removed, overrides } = compare(this.localUserConfiguration, user);
+        const keys = [...added, ...updated, ...removed];
+        if (keys.length) {
+            this.updateLocalUserConfiguration(user);
+        }
+        return { keys, overrides };
+    }
+    compareAndUpdateRemoteUserConfiguration(user) {
+        const { added, updated, removed, overrides } = compare(this.remoteUserConfiguration, user);
+        let keys = [...added, ...updated, ...removed];
+        if (keys.length) {
+            this.updateRemoteUserConfiguration(user);
+        }
+        return { keys, overrides };
+    }
+    compareAndUpdateWorkspaceConfiguration(workspaceConfiguration) {
+        const { added, updated, removed, overrides } = compare(this.workspaceConfiguration, workspaceConfiguration);
+        let keys = [...added, ...updated, ...removed];
+        if (keys.length) {
+            this.updateWorkspaceConfiguration(workspaceConfiguration);
+        }
+        return { keys, overrides };
+    }
+    compareAndUpdateFolderConfiguration(resource, folderConfiguration) {
+        const currentFolderConfiguration = this.folderConfigurations.get(resource);
+        const { added, updated, removed, overrides } = compare(currentFolderConfiguration, folderConfiguration);
+        let keys = [...added, ...updated, ...removed];
+        if (keys.length || !currentFolderConfiguration) {
+            this.updateFolderConfiguration(resource, folderConfiguration);
+        }
+        return { keys, overrides };
+    }
+    compareAndDeleteFolderConfiguration(folder) {
+        const folderConfig = this.folderConfigurations.get(folder);
+        if (!folderConfig) {
+            throw new Error('Unknown folder');
+        }
+        this.deleteFolderConfiguration(folder);
+        const { added, updated, removed, overrides } = compare(folderConfig, undefined);
+        return { keys: [...added, ...updated, ...removed], overrides };
+    }
+    get defaults() {
+        return this._defaultConfiguration;
+    }
+    get userConfiguration() {
+        if (!this._userConfiguration) {
+            this._userConfiguration = this._remoteUserConfiguration.isEmpty() ? this._localUserConfiguration : this._localUserConfiguration.merge(this._remoteUserConfiguration);
+            if (this._freeze) {
+                this._userConfiguration.freeze();
+            }
+        }
+        return this._userConfiguration;
+    }
+    get localUserConfiguration() {
+        return this._localUserConfiguration;
+    }
+    get remoteUserConfiguration() {
+        return this._remoteUserConfiguration;
+    }
+    get workspaceConfiguration() {
+        return this._workspaceConfiguration;
+    }
+    get folderConfigurations() {
+        return this._folderConfigurations;
+    }
+    getConsolidateConfigurationModel(overrides, workspace) {
+        let configurationModel = this.getConsolidatedConfigurationModelForResource(overrides, workspace);
+        return overrides.overrideIdentifier ? configurationModel.override(overrides.overrideIdentifier) : configurationModel;
+    }
+    getConsolidatedConfigurationModelForResource({ resource }, workspace) {
+        let consolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
+        if (workspace && resource) {
+            const root = workspace.getFolder(resource);
+            if (root) {
+                consolidateConfiguration = this.getFolderConsolidatedConfiguration(root.uri) || consolidateConfiguration;
+            }
+            const memoryConfigurationForResource = this._memoryConfigurationByResource.get(resource);
+            if (memoryConfigurationForResource) {
+                consolidateConfiguration = consolidateConfiguration.merge(memoryConfigurationForResource);
+            }
+        }
+        return consolidateConfiguration;
+    }
+    getWorkspaceConsolidatedConfiguration() {
+        if (!this._workspaceConsolidatedConfiguration) {
+            this._workspaceConsolidatedConfiguration = this._defaultConfiguration.merge(this.userConfiguration, this._workspaceConfiguration, this._memoryConfiguration);
+            if (this._freeze) {
+                this._workspaceConfiguration = this._workspaceConfiguration.freeze();
+            }
+        }
+        return this._workspaceConsolidatedConfiguration;
+    }
+    getFolderConsolidatedConfiguration(folder) {
+        let folderConsolidatedConfiguration = this._foldersConsolidatedConfigurations.get(folder);
+        if (!folderConsolidatedConfiguration) {
+            const workspaceConsolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
+            const folderConfiguration = this._folderConfigurations.get(folder);
+            if (folderConfiguration) {
+                folderConsolidatedConfiguration = workspaceConsolidateConfiguration.merge(folderConfiguration);
+                if (this._freeze) {
+                    folderConsolidatedConfiguration = folderConsolidatedConfiguration.freeze();
+                }
+                this._foldersConsolidatedConfigurations.set(folder, folderConsolidatedConfiguration);
+            }
+            else {
+                folderConsolidatedConfiguration = workspaceConsolidateConfiguration;
+            }
+        }
+        return folderConsolidatedConfiguration;
+    }
+    getFolderConfigurationModelForResource(resource, workspace) {
+        if (workspace && resource) {
+            const root = workspace.getFolder(resource);
+            if (root) {
+                return this._folderConfigurations.get(root.uri);
+            }
+        }
+        return undefined;
+    }
+    toData() {
+        return {
+            defaults: {
+                contents: this._defaultConfiguration.contents,
+                overrides: this._defaultConfiguration.overrides,
+                keys: this._defaultConfiguration.keys
+            },
+            user: {
+                contents: this.userConfiguration.contents,
+                overrides: this.userConfiguration.overrides,
+                keys: this.userConfiguration.keys
+            },
+            workspace: {
+                contents: this._workspaceConfiguration.contents,
+                overrides: this._workspaceConfiguration.overrides,
+                keys: this._workspaceConfiguration.keys
+            },
+            folders: [...this._folderConfigurations.keys()].reduce((result, folder) => {
+                const { contents, overrides, keys } = this._folderConfigurations.get(folder);
+                result.push([folder, { contents, overrides, keys }]);
+                return result;
+            }, [])
+        };
+    }
+    allKeys() {
+        const keys =  new Set();
+        this._defaultConfiguration.freeze().keys.forEach(key => keys.add(key));
+        this.userConfiguration.freeze().keys.forEach(key => keys.add(key));
+        this._workspaceConfiguration.freeze().keys.forEach(key => keys.add(key));
+        this._folderConfigurations.forEach(folderConfiguraiton => folderConfiguraiton.freeze().keys.forEach(key => keys.add(key)));
+        return [...keys.values()];
+    }
+    allOverrideIdentifiers() {
+        const keys =  new Set();
+        this._defaultConfiguration.freeze().getAllOverrideIdentifiers().forEach(key => keys.add(key));
+        this.userConfiguration.freeze().getAllOverrideIdentifiers().forEach(key => keys.add(key));
+        this._workspaceConfiguration.freeze().getAllOverrideIdentifiers().forEach(key => keys.add(key));
+        this._folderConfigurations.forEach(folderConfiguraiton => folderConfiguraiton.freeze().getAllOverrideIdentifiers().forEach(key => keys.add(key)));
+        return [...keys.values()];
+    }
+    getAllKeysForOverrideIdentifier(overrideIdentifier) {
+        const keys =  new Set();
+        this._defaultConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
+        this.userConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
+        this._workspaceConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
+        this._folderConfigurations.forEach(folderConfiguraiton => folderConfiguraiton.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key)));
+        return [...keys.values()];
+    }
+    static parse(data) {
+        const defaultConfiguration = this.parseConfigurationModel(data.defaults);
+        const userConfiguration = this.parseConfigurationModel(data.user);
+        const workspaceConfiguration = this.parseConfigurationModel(data.workspace);
+        const folders = data.folders.reduce((result, value) => {
+            result.set(URI.revive(value[0]), this.parseConfigurationModel(value[1]));
+            return result;
+        },  new ResourceMap());
+        return (
+             new Configuration(defaultConfiguration, userConfiguration,  new ConfigurationModel(), workspaceConfiguration, folders,  new ConfigurationModel(),  new ResourceMap(), false)
+        );
+    }
+    static parseConfigurationModel(model) {
+        return (
+             new ConfigurationModel(model.contents, model.keys, model.overrides).freeze()
+        );
+    }
+}
+function compare(from, to) {
+    const { added, removed, updated } = compareConfigurationContents(to, from);
+    const overrides = [];
+    const fromOverrideIdentifiers = from?.getAllOverrideIdentifiers() || [];
+    const toOverrideIdentifiers = to?.getAllOverrideIdentifiers() || [];
+    if (to) {
+        const addedOverrideIdentifiers = toOverrideIdentifiers.filter(key => !fromOverrideIdentifiers.includes(key));
+        for (const identifier of addedOverrideIdentifiers) {
+            overrides.push([identifier, to.getKeysForOverrideIdentifier(identifier)]);
+        }
+    }
+    if (from) {
+        const removedOverrideIdentifiers = fromOverrideIdentifiers.filter(key => !toOverrideIdentifiers.includes(key));
+        for (const identifier of removedOverrideIdentifiers) {
+            overrides.push([identifier, from.getKeysForOverrideIdentifier(identifier)]);
+        }
+    }
+    if (to && from) {
+        for (const identifier of fromOverrideIdentifiers) {
+            if (toOverrideIdentifiers.includes(identifier)) {
+                const result = compareConfigurationContents({ contents: from.getOverrideValue(undefined, identifier) || {}, keys: from.getKeysForOverrideIdentifier(identifier) }, { contents: to.getOverrideValue(undefined, identifier) || {}, keys: to.getKeysForOverrideIdentifier(identifier) });
+                overrides.push([identifier, [...result.added, ...result.removed, ...result.updated]]);
+            }
+        }
+    }
+    return { added, removed, updated, overrides };
+}
+function compareConfigurationContents(to, from) {
+    const added = to
+        ? from ? to.keys.filter(key => from.keys.indexOf(key) === -1) : [...to.keys]
+        : [];
+    const removed = from
+        ? to ? from.keys.filter(key => to.keys.indexOf(key) === -1) : [...from.keys]
+        : [];
+    const updated = [];
+    if (to && from) {
+        for (const key of from.keys) {
+            if (to.keys.indexOf(key) !== -1) {
+                const value1 = getConfigurationValue(from.contents, key);
+                const value2 = getConfigurationValue(to.contents, key);
+                if (!equals(value1, value2)) {
+                    updated.push(key);
+                }
+            }
+        }
+    }
+    return { added, removed, updated };
+}
+var _a, _b, _c, _d, _e, _f;
+Object.defineProperties(Configuration$1.prototype, Object.getOwnPropertyDescriptors(Configuration.prototype));
+Object.defineProperties(TernarySearchTree$1.prototype, Object.getOwnPropertyDescriptors(TernarySearchTree.prototype));
+(_a = StandaloneConfigurationService.prototype).getConfigurationData ?? (_a.getConfigurationData = () => {
+    const emptyModel = {
+        contents: {},
+        keys: [],
+        overrides: []
+    };
+    return {
+        defaults: emptyModel,
+        user: emptyModel,
+        workspace: emptyModel,
+        folders: []
+    };
+});
+const configurationRegistry = Registry.as(Extensions.Configuration);
+configurationRegistry.onDidUpdateConfiguration ?? (configurationRegistry.onDidUpdateConfiguration = configurationRegistry._onDidUpdateConfiguration.event);
+(_b = NoOpNotification.prototype).onDidClose ?? (_b.onDidClose = Event.None);
+Object.defineProperties(NoOpNotification.prototype, Object.getOwnPropertyDescriptors(NoOpNotification$1.prototype));
+(_c = LanguageService$1.prototype).getRegisteredLanguageIds ?? (_c.getRegisteredLanguageIds = LanguageService.prototype.getRegisteredLanguageIds);
+(_d = ProgressBar$1.prototype).hide ?? (_d.hide = ProgressBar.prototype.hide);
+(_e = Themable$1.prototype)['getColor'] ?? (_e['getColor'] = Themable.prototype['getColor']);
+function polyfillQuickInput(fn) {
+    return function () {
+        const quickInput = fn.call(this);
+        quickInput.onDidTriggerButton ?? (quickInput.onDidTriggerButton = quickInput.onDidTriggerButtonEmitter.event);
+        return quickInput;
+    };
+}
+QuickInputController.prototype.createQuickPick = polyfillQuickInput(QuickInputController.prototype.createQuickPick);
+QuickInputController.prototype.createInputBox = polyfillQuickInput(QuickInputController.prototype.createInputBox);
+const StandaloneUriLabelService = getSingletonServiceDescriptors().find(([id]) => id === ILabelService)[1].ctor;
+(_f = StandaloneUriLabelService.prototype).onDidChangeFormatters ?? (_f.onDidChangeFormatters = Event.None);
+function toVSCodeVSBuffer(value) {
+    if (value instanceof VSBuffer$1) {
+        return VSBuffer.wrap(value.buffer);
+    }
+    return value;
+}
+function toMonacoVSBuffer(value) {
+    if (value instanceof VSBuffer) {
+        return VSBuffer$1.wrap(value.buffer);
+    }
+    return value;
+}
+for (const key of Object.getOwnPropertyNames(VSBuffer)) {
+    if (!Object.hasOwnProperty.call(VSBuffer$1, key)) {
+        const method = VSBuffer[key];
+        VSBuffer[key] = VSBuffer$1[key] = function (...args) {
+            return toMonacoVSBuffer(method.call(VSBuffer$1, ...args.map(toVSCodeVSBuffer)));
+        };
+    }
+}
+for (const key of Object.getOwnPropertyNames(VSBuffer.prototype)) {
+    if (!Object.hasOwnProperty.call(VSBuffer$1.prototype, key)) {
+        VSBuffer$1.prototype[key] = function (...args) {
+            return toMonacoVSBuffer(VSBuffer.prototype[key].call(this, ...args.map(toVSCodeVSBuffer)));
+        };
+    }
+}
+const ILifecycleService =  createDecorator('lifecycleService');
+const ILanguageDetectionService =  createDecorator('ILanguageDetectionService');
+function unsupported() {
+    throw new Error('unsupported');
+}
+registerSingleton(IEditorService, class EditorService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.onDidActiveEditorChange = Event.None;
+        this.onDidVisibleEditorsChange = Event.None;
+        this.onDidEditorsChange = Event.None;
+        this.onDidCloseEditor = Event.None;
+        this.activeEditorPane = undefined;
+        this.activeEditor = undefined;
+        this.activeTextEditorControl = undefined;
+        this.activeTextEditorLanguageId = undefined;
+        this.visibleEditorPanes = [];
+        this.visibleEditors = [];
+        this.visibleTextEditorControls = [];
+        this.editors = [];
+        this.count = 0;
+        this.getEditors = () => [];
+        this.openEditor = unsupported;
+        this.openEditors = unsupported;
+        this.replaceEditors = async () => { };
+        this.isOpened = () => false;
+        this.isVisible = () => false;
+        this.closeEditor = async () => { };
+        this.closeEditors = async () => { };
+        this.findEditors = () => [];
+        this.save = async () => false;
+        this.saveAll = async () => false;
+        this.revert = async () => false;
+        this.revertAll = async () => false;
+    }
+});
+registerSingleton(IPaneCompositePartService, class PaneCompositePartService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.onDidPaneCompositeOpen = Event.None;
+        this.onDidPaneCompositeClose = Event.None;
+        this.openPaneComposite = unsupported;
+        this.getActivePaneComposite = () => undefined;
+        this.getPaneComposite = () => undefined;
+        this.getPaneComposites = () => [];
+        this.getPinnedPaneCompositeIds = () => [];
+        this.getVisiblePaneCompositeIds = () => [];
+        this.getProgressIndicator = () => undefined;
+        this.hideActivePaneComposite = () => { };
+        this.getLastActivePaneCompositeId = unsupported;
+        this.showActivity = unsupported;
+    }
+});
+registerSingleton(IUriIdentityService, class UriIdentityService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.extUri = new ExtUri(() => false);
+    }
+    asCanonicalUri(uri) {
+        return uri;
+    }
+});
+const onDidSave = new Emitter();
+class TextFileEditorModelManager {
+    constructor() {
+        this.onDidCreate = Event.None;
+        this.onDidResolve = Event.None;
+        this.onDidChangeDirty = Event.None;
+        this.onDidChangeReadonly = Event.None;
+        this.onDidRemove = Event.None;
+        this.onDidChangeOrphaned = Event.None;
+        this.onDidChangeEncoding = Event.None;
+        this.onDidSaveError = Event.None;
+        this.onDidSave = onDidSave.event;
+        this.onDidRevert = Event.None;
+        this.models = [];
+        this.saveErrorHandler = {
+            onSaveError: unsupported
+        };
+        this.get = () => undefined;
+        this.resolve = unsupported;
+        this.addSaveParticipant = unsupported;
+        this.runSaveParticipants = unsupported;
+    }
+    canDispose() {
+        return true;
+    }
+}
+registerSingleton(ITextFileService, class TextFileService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.files = new TextFileEditorModelManager();
+        this.isDirty = () => false;
+        this.save = unsupported;
+        this.saveAs = unsupported;
+        this.revert = unsupported;
+        this.read = unsupported;
+        this.readStream = unsupported;
+        this.write = unsupported;
+        this.create = unsupported;
+        this.getEncodedReadable = unsupported;
+        this.getDecodedStream = unsupported;
+    }
+    get untitled() { return unsupported(); }
+    get encoding() { return unsupported(); }
+    dispose() {
+    }
+});
+registerSingleton(IFileService, class FileService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.onDidChangeFileSystemProviderRegistrations = Event.None;
+        this.onDidChangeFileSystemProviderCapabilities = Event.None;
+        this.onWillActivateFileSystemProvider = Event.None;
+        this.registerProvider = unsupported;
+        this.getProvider = function () {
+            return undefined;
+        };
+        this.activateProvider = async () => { };
+        this.canHandleResource = async () => false;
+        this.hasProvider = () => false;
+        this.hasCapability = () => false;
+        this.listCapabilities = () => [];
+        this.onDidFilesChange = Event.None;
+        this.onDidRunOperation = Event.None;
+        this.resolve = unsupported;
+        this.resolveAll = unsupported;
+        this.stat = unsupported;
+        this.exists = async () => false;
+        this.readFile = unsupported;
+        this.readFileStream = unsupported;
+        this.writeFile = unsupported;
+        this.move = unsupported;
+        this.canMove = unsupported;
+        this.copy = unsupported;
+        this.canCopy = unsupported;
+        this.cloneFile = unsupported;
+        this.createFile = unsupported;
+        this.canCreateFile = unsupported;
+        this.createFolder = unsupported;
+        this.del = unsupported;
+        this.canDelete = unsupported;
+        this.onDidWatchError = Event.None;
+        this.watch = unsupported;
+    }
+    dispose() {
+    }
+});
+class EmptyEditorGroup {
+    constructor() {
+        this.onDidModelChange = Event.None;
+        this.onWillDispose = Event.None;
+        this.onDidActiveEditorChange = Event.None;
+        this.onWillCloseEditor = Event.None;
+        this.onDidCloseEditor = Event.None;
+        this.onWillMoveEditor = Event.None;
+        this.onWillOpenEditor = Event.None;
+        this.id = 0;
+        this.index = 0;
+        this.label = 'main';
+        this.ariaLabel = 'main';
+        this.activeEditorPane = undefined;
+        this.activeEditor = null;
+        this.previewEditor = null;
+        this.count = 0;
+        this.isEmpty = false;
+        this.isLocked = false;
+        this.stickyCount = 0;
+        this.editors = [];
+        this.getEditors = unsupported;
+        this.findEditors = unsupported;
+        this.getEditorByIndex = unsupported;
+        this.getIndexOfEditor = unsupported;
+        this.openEditor = unsupported;
+        this.openEditors = unsupported;
+        this.isPinned = unsupported;
+        this.isSticky = unsupported;
+        this.isActive = unsupported;
+        this.contains = unsupported;
+        this.moveEditor = unsupported;
+        this.moveEditors = unsupported;
+        this.copyEditor = unsupported;
+        this.copyEditors = unsupported;
+        this.closeEditor = unsupported;
+        this.closeEditors = unsupported;
+        this.closeAllEditors = unsupported;
+        this.replaceEditors = unsupported;
+        this.pinEditor = unsupported;
+        this.stickEditor = unsupported;
+        this.unstickEditor = unsupported;
+        this.lock = unsupported;
+    }
+    get scopedContextKeyService() { return unsupported(); }
+    focus() {
+    }
+}
+registerSingleton(IEditorGroupsService, class EditorGroupsService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.onDidChangeActiveGroup = Event.None;
+        this.onDidAddGroup = Event.None;
+        this.onDidRemoveGroup = Event.None;
+        this.onDidMoveGroup = Event.None;
+        this.onDidActivateGroup = Event.None;
+        this.onDidLayout = Event.None;
+        this.onDidScroll = Event.None;
+        this.onDidChangeGroupIndex = Event.None;
+        this.onDidChangeGroupLocked = Event.None;
+        this.activeGroup = new EmptyEditorGroup();
+        this.groups = [];
+        this.count = 0;
+        this.orientation = 0 ;
+        this.isReady = false;
+        this.whenReady = Promise.resolve();
+        this.whenRestored = Promise.resolve();
+        this.hasRestorableState = false;
+        this.getGroups = () => [];
+        this.getGroup = () => undefined;
+        this.activateGroup = unsupported;
+        this.getSize = unsupported;
+        this.setSize = unsupported;
+        this.arrangeGroups = unsupported;
+        this.applyLayout = unsupported;
+        this.centerLayout = unsupported;
+        this.isLayoutCentered = () => false;
+        this.setGroupOrientation = unsupported;
+        this.findGroup = () => undefined;
+        this.addGroup = unsupported;
+        this.removeGroup = unsupported;
+        this.moveGroup = unsupported;
+        this.mergeGroup = unsupported;
+        this.mergeAllGroups = unsupported;
+        this.copyGroup = unsupported;
+        this.onDidChangeEditorPartOptions = Event.None;
+        this.enforcePartOptions = unsupported;
+    }
+    get contentDimension() { return unsupported(); }
+    get sideGroup() { return unsupported(); }
+    get partOptions() { return unsupported(); }
+});
+registerSingleton(IWorkbenchEnvironmentService, class WorkbenchEnvironmentService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.skipReleaseNotes = true;
+        this.skipWelcome = true;
+        this.disableWorkspaceTrust = true;
+        this.debugRenderer = false;
+        this.sync = undefined;
+        this.isExtensionDevelopment = false;
+        this.disableExtensions = false;
+        this.logsPath = '';
+        this.verbose = false;
+        this.isBuilt = false;
+        this.disableTelemetry = false;
+    }
+    get logFile() { return unsupported(); }
+    get extHostLogsPath() { return unsupported(); }
+    get webviewExternalEndpoint() { return unsupported(); }
+    get userRoamingDataHome() { return unsupported(); }
+    get settingsResource() { return unsupported(); }
+    get keybindingsResource() { return unsupported(); }
+    get keyboardLayoutResource() { return unsupported(); }
+    get argvResource() { return unsupported(); }
+    get snippetsHome() { return unsupported(); }
+    get untitledWorkspacesHome() { return unsupported(); }
+    get globalStorageHome() { return unsupported(); }
+    get workspaceStorageHome() { return unsupported(); }
+    get localHistoryHome() { return unsupported(); }
+    get cacheHome() { return unsupported(); }
+    get userDataSyncHome() { return unsupported(); }
+    get userDataSyncLogResource() { return unsupported(); }
+    get debugExtensionHost() { return unsupported(); }
+    get telemetryLogResource() { return unsupported(); }
+    get serviceMachineIdResource() { return unsupported(); }
+});
+registerSingleton(IWorkingCopyFileService, class WorkingCopyFileService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.onWillRunWorkingCopyFileOperation = Event.None;
+        this.onDidFailWorkingCopyFileOperation = Event.None;
+        this.onDidRunWorkingCopyFileOperation = Event.None;
+        this.addFileOperationParticipant = unsupported;
+        this.hasSaveParticipants = false;
+        this.addSaveParticipant = unsupported;
+        this.runSaveParticipants = unsupported;
+        this.create = unsupported;
+        this.createFolder = unsupported;
+        this.move = unsupported;
+        this.copy = unsupported;
+        this.delete = unsupported;
+        this.registerWorkingCopyProvider = unsupported;
+        this.getDirty = unsupported;
+    }
+});
+registerSingleton(IPathService, class PathService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.defaultUriScheme = Schemas.file;
+        this.userHome = unsupported;
+        this.hasValidBasename = unsupported;
+        this.resolvedUserHome = undefined;
+    }
+    get path() { return unsupported(); }
+    async fileURI(path) {
+        return URI.file(path);
+    }
+});
+registerSingleton(IProgressService, class ProgressService {
+    constructor() {
+        this._serviceBrand = undefined;
+    }
+    withProgress(options, task, onDidCancel) {
+        const { window } = Services.get();
+        if (window?.withProgress != null) {
+            return window.withProgress(options, task, onDidCancel);
+        }
+        return task({ report: () => { } });
+    }
+});
+registerSingleton(IProductService, class ProductService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.version = "1.67.0";
+        this.nameShort = 'Code - OSS Dev';
+        this.nameLong = 'Code - OSS Dev';
+        this.applicationName = 'code-oss';
+        this.dataFolderName = '.vscode-oss';
+        this.urlProtocol = 'code-oss';
+        this.reportIssueUrl = 'https://github.com/microsoft/vscode/issues/new';
+        this.licenseName = 'MIT';
+        this.licenseUrl = 'https://github.com/microsoft/vscode/blob/main/LICENSE.txt';
+        this.serverApplicationName = 'code-server-oss';
+    }
+});
+registerSingleton(ILanguageStatusService, class LanguageStatusServiceImpl {
+    constructor() {
+        this._provider = new LanguageFeatureRegistry();
+        this.onDidChange = this._provider.onDidChange;
+    }
+    addStatus(status) {
+        return this._provider.register(status.selector, status);
+    }
+    getLanguageStatus(model) {
+        return this._provider.ordered(model).sort((a, b) => {
+            let res = b.severity - a.severity;
+            if (res === 0) {
+                res = compare$1(a.source, b.source);
+            }
+            if (res === 0) {
+                res = compare$1(a.id, b.id);
+            }
+            return res;
+        });
+    }
+});
+const focusTracker = trackFocus(window);
+const onVisibilityChange = new DomEmitter(window.document, 'visibilitychange');
+const onDidChangeFocus = Event.latch(Event.any(Event.map(focusTracker.onDidFocus, () => document.hasFocus()), Event.map(focusTracker.onDidBlur, () => document.hasFocus()), Event.map(onVisibilityChange.event, () => document.hasFocus())));
+registerSingleton(IHostService, class HostService {
+    constructor() {
+        this.onDidChangeFocus = onDidChangeFocus;
+        this.openWindow = unsupported;
+        this.restart = unsupported;
+        this.reload = unsupported;
+        this.close = unsupported;
+    }
+    get hasFocus() {
+        return document.hasFocus();
+    }
+    async hadLastFocus() {
+        return true;
+    }
+    async focus() {
+        window.focus();
+    }
+    async toggleFullScreen() {
+        if (document.fullscreenEnabled) {
+            await document.body.requestFullscreen();
+        }
+        else {
+            await document.exitFullscreen();
+        }
+    }
+});
+registerSingleton(ILifecycleService, class LifecycleService {
+    constructor() {
+        this.startupKind = 1 ;
+        this.phase = 2 ;
+        this.onBeforeShutdown = Event.None;
+        this.onShutdownVeto = Event.None;
+        this.onBeforeShutdownError = Event.None;
+        this.onWillShutdown = Event.None;
+        this.onDidShutdown = Event.None;
+        this.shutdown = unsupported;
+    }
+    async when() {
+    }
+});
+registerSingleton(ILanguageDetectionService, class LanguageDetectionService {
+    isEnabledForLanguage() {
+        return false;
+    }
+    async detectLanguage() {
+        return undefined;
+    }
+});
+export { Emitter as E, ILifecycleService as I, UserSettings as U, ILanguageDetectionService as a, peekReadable as b, bufferToReadable as c, consumeStream as d, isReadableBufferedStream as e, bufferedStreamToBuffer as f, newWriteableStream as g, isReadableStream as i, listenStream as l, newWriteableBufferStream as n, peekStream as p, readableToBuffer as r, streamToBuffer as s, transform as t, unsupported as u };