@codingame/monaco-vscode-api 1.67.12 → 1.67.15

package/dist/{missing-services-71e80bea.js → missing-services-8687ea11.js}

@@ -1,24 +1,27 @@
 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 { 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 { 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 as NoOpNotification$1 } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { NoOpNotification } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { N as NoOpNotification$1, o as IEditorService, q as IPaneCompositePartService, j as IUriIdentityService, g as ITextFileService, h as IFileService, p as IEditorGroupsService, i as IWorkbenchEnvironmentService, k as IWorkingCopyFileService, l as IPathService, I as IProgressService, v as Services, s as IProductService, t as ILanguageStatusService, u as IHostService } from './services-7a462d46.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 { 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';
@@ -26,6 +29,331 @@ 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;
@@ -186,6 +514,27 @@ function readUInt8(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) {
@@ -208,39 +557,13 @@ class Themable extends Disposable {
         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')
+    progressBarBackground:  Color.fromHex('#0E70C0')
 };
 class ProgressBar extends Disposable {
     constructor(container, options) {
@@ -503,39 +826,13 @@ class LanguageSelection {
         }
     }
 }
-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];
+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);
@@ -566,8 +863,9 @@ function toMonacoVSBuffer(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)));
+        const method = VSBuffer[key];
+        VSBuffer[key] = VSBuffer$1[key] = function (...args) {
+            return toMonacoVSBuffer(method.call(VSBuffer$1, ...args.map(toVSCodeVSBuffer)));
         };
     }
 }
@@ -984,4 +1282,4 @@ registerSingleton(ILanguageDetectionService, class LanguageDetectionService {
         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 };
+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 };

package/dist/modelEditor.js

@@ -1,6 +1,7 @@
-import { b as __decorate, d as __param, f as IFileService, h as IUriIdentityService, e as ITextFileService, S as SIDE_GROUP, A as ACTIVE_GROUP, l as IEditorService, x as isPreferredGroup } from './services-fb7952fb.js';
-import { E as Emitter, w as withUndefinedAsNull, c as ILanguageDetectionService, u as unsupported } from './missing-services-71e80bea.js';
-import { Disposable, MutableDisposable, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { b as __decorate, d as __param, h as IFileService, j as IUriIdentityService, g as ITextFileService, S as SIDE_GROUP, A as ACTIVE_GROUP, o as IEditorService, D as isPreferredGroup } from './services-7a462d46.js';
+import { E as Emitter, a as ILanguageDetectionService, u as unsupported } from './missing-services-8687ea11.js';
+import { Disposable, MutableDisposable, dispose, toDisposable, ImmortalReference } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { w as withUndefinedAsNull } from './types-371cc315.js';
 import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
 import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
@@ -31,6 +32,7 @@ import 'monaco-editor/esm/vs/base/common/path.js';
 import 'monaco-editor/esm/vs/base/common/linkedList.js';
 import 'monaco-editor/esm/vs/platform/log/common/log.js';
 import 'monaco-editor/esm/vs/editor/editor.api.js';
+import 'monaco-editor/esm/vs/base/common/map.js';
 import 'monaco-editor/esm/vs/base/common/errors.js';
 import 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import 'monaco-editor/esm/vs/base/common/cancellation.js';
@@ -49,13 +51,15 @@ import 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
 import 'monaco-editor/esm/vs/base/common/severity.js';
 import 'monaco-editor/esm/vs/base/common/buffer.js';
 import 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
-import 'monaco-editor/esm/vs/base/common/color.js';
 import 'monaco-editor/esm/vs/base/common/objects.js';
 import 'monaco-editor/esm/vs/base/common/types.js';
+import 'monaco-editor/esm/vs/base/common/color.js';
 import 'monaco-editor/esm/vs/editor/common/services/languageService.js';
 import 'monaco-editor/esm/vs/editor/common/services/languagesRegistry.js';
 import 'monaco-editor/esm/vs/base/common/arrays.js';
 import 'monaco-editor/esm/vs/editor/common/languages.js';
+import 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import 'monaco-editor/esm/vs/base/parts/quickinput/browser/quickInput.js';
 import 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
 import 'monaco-editor/esm/vs/platform/label/common/label.js';
@@ -680,6 +684,7 @@ let EditorService = class EditorService {
         let newModelRef;
         if (model == null) {
             const modelRef = await this.textModelService.createModelReference(resource);
+            newModelRef = modelRef;
             model = modelRef.object.textEditorModel;
         }
         else {
@@ -703,15 +708,31 @@ let EditorService = class EditorService {
 EditorService = __decorate([
     __param(1, ITextModelService)
 ], EditorService);
-class CustomTextModelResolverService extends TextModelResolverService {
+let CustomTextModelResolverService = class CustomTextModelResolverService extends TextModelResolverService {
+    constructor(_instantiationService, fileService, undoRedoService, _modelService, uriIdentityService) {
+        super(_instantiationService, fileService, undoRedoService, _modelService, uriIdentityService);
+        this._instantiationService = _instantiationService;
+        this._modelService = _modelService;
+    }
     async createModelReference(resource) {
+        const existingModel = this._modelService.getModel(resource);
+        if (existingModel != null) {
+            return new ImmortalReference(this._instantiationService.createInstance(TextResourceEditorModel, resource));
+        }
         const ref = await super.createModelReference(resource);
         ref.object.textEditorModel.onWillDispose(() => {
             ref.dispose();
         });
         return ref;
     }
-}
+};
+CustomTextModelResolverService = __decorate([
+    __param(0, IInstantiationService),
+    __param(1, IFileService),
+    __param(2, IUndoRedoService),
+    __param(3, IModelService),
+    __param(4, IUriIdentityService)
+], CustomTextModelResolverService);
 function getServiceOverride(openEditor) {
     return {
         [ITextModelService.toString()]: new SyncDescriptor(CustomTextModelResolverService),