@codingame/monaco-vscode-api 1.67.17 → 1.67.20

package/dist/missing-services-597951f0.js

@@ -1,1285 +0,0 @@
-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 } 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 } 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 } 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 { 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-9299c4ca.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.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 { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
-import { compare } from 'monaco-editor/esm/vs/base/common/strings.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);
-        }
-    }
-}
-var _a, _b, _c, _d, _e;
-const configurationRegistry = Registry.as(Extensions.Configuration);
-configurationRegistry.onDidUpdateConfiguration ?? (configurationRegistry.onDidUpdateConfiguration = configurationRegistry._onDidUpdateConfiguration.event);
-(_a = NoOpNotification.prototype).onDidClose ?? (_a.onDidClose = Event.None);
-for (const key of Object.getOwnPropertyNames(NoOpNotification$1.prototype)) {
-    if (!Object.hasOwnProperty.call(NoOpNotification.prototype, key)) {
-        NoOpNotification.prototype[key] = NoOpNotification$1.prototype[key];
-    }
-}
-(_b = LanguageService$1.prototype).getRegisteredLanguageIds ?? (_b.getRegisteredLanguageIds = LanguageService.prototype.getRegisteredLanguageIds);
-(_c = ProgressBar$1.prototype).hide ?? (_c.hide = ProgressBar.prototype.hide);
-(_d = Themable$1.prototype)['getColor'] ?? (_d['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;
-(_e = StandaloneUriLabelService.prototype).onDidChangeFormatters ?? (_e.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(a.source, b.source);
-            }
-            if (res === 0) {
-                res = compare(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, 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 };