@codingame/monaco-vscode-api 1.67.8 → 1.67.11

package/dist/missing-services-71e80bea.js

@@ -0,0 +1,987 @@
+import { VSBuffer as VSBuffer$1 } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Themable as Themable$1 } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ProgressBar as ProgressBar$1 } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.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 { 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 as NoOpNotification$1 } from 'monaco-editor/esm/vs/platform/notification/common/notification.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 { l as IEditorService, o as IPaneCompositePartService, h as IUriIdentityService, e as ITextFileService, f as IFileService, n as IEditorGroupsService, g as IWorkbenchEnvironmentService, i as IWorkingCopyFileService, j as IPathService, I as IProgressService, t as Services, p as IProductService, q as ILanguageStatusService, s as IHostService } from './services-fb7952fb.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';
+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;
+}
+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;
+    }
+}
+function isString(str) {
+    return (typeof str === 'string');
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(elem => isString(elem));
+}
+function isUndefined(obj) {
+    return (typeof obj === 'undefined');
+}
+function isUndefinedOrNull(obj) {
+    return (isUndefined(obj) || obj === null);
+}
+function assertAllDefined(...args) {
+    const result = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (isUndefinedOrNull(arg)) {
+            throw new Error(`Assertion Failed: argument at index ${i} is undefined or null`);
+        }
+        result.push(arg);
+    }
+    return result;
+}
+function withUndefinedAsNull(x) {
+    return typeof x === 'undefined' ? null : x;
+}
+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 NeverShowAgainScope;
+ (function(NeverShowAgainScope) {
+    NeverShowAgainScope[NeverShowAgainScope["WORKSPACE"] = 0] = "WORKSPACE";
+    NeverShowAgainScope[NeverShowAgainScope["GLOBAL"] = 1] = "GLOBAL";
+})(NeverShowAgainScope || (NeverShowAgainScope = {}));
+var NotificationsFilter;
+ (function(NotificationsFilter) {
+    NotificationsFilter[NotificationsFilter["OFF"] = 0] = "OFF";
+    NotificationsFilter[NotificationsFilter["SILENT"] = 1] = "SILENT";
+    NotificationsFilter[NotificationsFilter["ERROR"] = 2] = "ERROR";
+})(NotificationsFilter || (NotificationsFilter = {}));
+class NoOpNotification {
+    constructor() {
+        this.progress =  new NoOpProgress();
+        this.onDidClose = Event.None;
+        this.onDidChangeVisibility = Event.None;
+    }
+    updateSeverity(severity) { }
+    updateMessage(message) { }
+    updateActions(actions) { }
+    close() { }
+}
+class NoOpProgress {
+    infinite() { }
+    done() { }
+    total(value) { }
+    worked(value) { }
+}
+var _a, _b, _c, _d, _e;
+(_a = NoOpNotification$1.prototype).onDidClose ?? (_a.onDidClose = Event.None);
+for (const key of Object.getOwnPropertyNames(NoOpNotification.prototype)) {
+    if (!Object.hasOwnProperty.call(NoOpNotification$1.prototype, key)) {
+        NoOpNotification$1.prototype[key] = NoOpNotification.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)) {
+        VSBuffer$1[key] = function (...args) {
+            return toMonacoVSBuffer(VSBuffer[key].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, NotificationsFilter as N, assertAllDefined as a, NeverShowAgainScope as b, ILanguageDetectionService as c, isStringArray as i, unsupported as u, withUndefinedAsNull as w };