@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/base/common/stream.js

@@ -0,0 +1,300 @@
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.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 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 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;
+}
+export { consumeStream, isReadableBufferedStream, isReadableStream, listenStream, newWriteableStream, peekReadable, peekStream, transform };

package/dist/vscode/vs/base/common/uriIpc.js

@@ -0,0 +1,32 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+function _transformIncomingURIs(obj, transformer, revive, depth) {
+    if (!obj || depth > 200) {
+        return null;
+    }
+    if (typeof obj === 'object') {
+        if (obj.$mid === 1 ) {
+            return revive ? URI.revive(transformer.transformIncoming(obj)) : transformer.transformIncoming(obj);
+        }
+        if (obj instanceof VSBuffer) {
+            return null;
+        }
+        for (const key in obj) {
+            if (Object.hasOwnProperty.call(obj, key)) {
+                const r = _transformIncomingURIs(obj[key], transformer, revive, depth + 1);
+                if (r !== null) {
+                    obj[key] = r;
+                }
+            }
+        }
+    }
+    return null;
+}
+function transformIncomingURIs(obj, transformer) {
+    const result = _transformIncomingURIs(obj, transformer, false, 0);
+    if (result === null) {
+        return obj;
+    }
+    return result;
+}
+export { transformIncomingURIs };

package/dist/vscode/vs/base/parts/ipc/common/ipc.net.js

@@ -0,0 +1,45 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+class BufferedEmitter {
+    constructor() {
+        this._hasListeners = false;
+        this._isDeliveringMessages = false;
+        this._bufferedMessages = [];
+        this._emitter = ( new Emitter({
+            onWillAddFirstListener: () => {
+                this._hasListeners = true;
+                queueMicrotask(() => this._deliverMessages());
+            },
+            onDidRemoveLastListener: () => {
+                this._hasListeners = false;
+            }
+        }));
+        this.event = this._emitter.event;
+    }
+    _deliverMessages() {
+        if (this._isDeliveringMessages) {
+            return;
+        }
+        this._isDeliveringMessages = true;
+        while (this._hasListeners && this._bufferedMessages.length > 0) {
+            this._emitter.fire(this._bufferedMessages.shift());
+        }
+        this._isDeliveringMessages = false;
+    }
+    fire(event) {
+        if (this._hasListeners) {
+            if (this._bufferedMessages.length > 0) {
+                this._bufferedMessages.push(event);
+            }
+            else {
+                this._emitter.fire(event);
+            }
+        }
+        else {
+            this._bufferedMessages.push(event);
+        }
+    }
+    flushBuffer() {
+        this._bufferedMessages = [];
+    }
+}
+export { BufferedEmitter };

package/dist/vscode/vs/base/parts/request/browser/request.js

@@ -0,0 +1,60 @@
+import { bufferToStream, VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { OfflineError } from '../common/request.js';
+function request(options, token) {
+    if (options.proxyAuthorization) {
+        options.headers = {
+            ...(options.headers || {}),
+            'Proxy-Authorization': options.proxyAuthorization
+        };
+    }
+    const xhr = ( new XMLHttpRequest());
+    return ( new Promise((resolve, reject) => {
+        xhr.open(options.type || 'GET', options.url || '', true, options.user, options.password);
+        setRequestHeaders(xhr, options);
+        xhr.responseType = 'arraybuffer';
+        xhr.onerror = e => reject(navigator.onLine ? ( new Error(xhr.statusText && ('XHR failed: ' + xhr.statusText) || 'XHR failed')) : ( new OfflineError()));
+        xhr.onload = (e) => {
+            resolve({
+                res: {
+                    statusCode: xhr.status,
+                    headers: getResponseHeaders(xhr)
+                },
+                stream: bufferToStream(VSBuffer.wrap(( new Uint8Array(xhr.response))))
+            });
+        };
+        xhr.ontimeout = e => reject(( new Error(`XHR timeout: ${options.timeout}ms`)));
+        if (options.timeout) {
+            xhr.timeout = options.timeout;
+        }
+        xhr.send(options.data);
+        token.onCancellationRequested(() => {
+            xhr.abort();
+            reject(canceled());
+        });
+    }));
+}
+function setRequestHeaders(xhr, options) {
+    if (options.headers) {
+        outer: for (const k in options.headers) {
+            switch (k) {
+                case 'User-Agent':
+                case 'Accept-Encoding':
+                case 'Content-Length':
+                    continue outer;
+            }
+            xhr.setRequestHeader(k, options.headers[k]);
+        }
+    }
+}
+function getResponseHeaders(xhr) {
+    const headers = Object.create(null);
+    for (const line of xhr.getAllResponseHeaders().split(/\r\n|\n|\r/g)) {
+        if (line) {
+            const idx = line.indexOf(':');
+            headers[line.substr(0, idx).trim().toLowerCase()] = line.substr(idx + 1).trim();
+        }
+    }
+    return headers;
+}
+export { request };

package/dist/vscode/vs/base/parts/request/common/request.js

@@ -0,0 +1,8 @@
+const offlineName = 'Offline';
+class OfflineError extends Error {
+    constructor() {
+        super(offlineName);
+        this.name = this.message;
+    }
+}
+export { OfflineError };

package/dist/vscode/vs/editor/browser/config/editorConfiguration.js

@@ -0,0 +1,91 @@
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { editorOptionsRegistry, ConfigurationChangedEvent } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
+class ValidatedEditorOptions {
+    constructor() {
+        this._values = [];
+    }
+    _read(option) {
+        return this._values[option];
+    }
+    get(id) {
+        return this._values[id];
+    }
+    _write(option, value) {
+        this._values[option] = value;
+    }
+}
+class ComputedEditorOptions {
+    constructor() {
+        this._values = [];
+    }
+    _read(id) {
+        if (id >= this._values.length) {
+            throw new Error('Cannot read uninitialized value');
+        }
+        return this._values[id];
+    }
+    get(id) {
+        return this._read(id);
+    }
+    _write(id, value) {
+        this._values[id] = value;
+    }
+}
+class EditorOptionsUtil {
+    static validateOptions(options) {
+        const result = ( new ValidatedEditorOptions());
+        for (const editorOption of editorOptionsRegistry) {
+            const value = (editorOption.name === '_never_' ? undefined : options[editorOption.name]);
+            result._write(editorOption.id, editorOption.validate(value));
+        }
+        return result;
+    }
+    static computeOptions(options, env) {
+        const result = ( new ComputedEditorOptions());
+        for (const editorOption of editorOptionsRegistry) {
+            result._write(editorOption.id, editorOption.compute(env, result, options._read(editorOption.id)));
+        }
+        return result;
+    }
+    static _deepEquals(a, b) {
+        if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
+            return a === b;
+        }
+        if (Array.isArray(a) || Array.isArray(b)) {
+            return (Array.isArray(a) && Array.isArray(b) ? arrays.equals(a, b) : false);
+        }
+        if (( Object.keys(a)).length !== ( Object.keys(b)).length) {
+            return false;
+        }
+        for (const key in a) {
+            if (!EditorOptionsUtil._deepEquals(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static checkEquals(a, b) {
+        const result = [];
+        let somethingChanged = false;
+        for (const editorOption of editorOptionsRegistry) {
+            const changed = !EditorOptionsUtil._deepEquals(a._read(editorOption.id), b._read(editorOption.id));
+            result[editorOption.id] = changed;
+            if (changed) {
+                somethingChanged = true;
+            }
+        }
+        return (somethingChanged ? ( new ConfigurationChangedEvent(result)) : null);
+    }
+    static applyUpdate(options, update) {
+        let changed = false;
+        for (const editorOption of editorOptionsRegistry) {
+            if (update.hasOwnProperty(editorOption.name)) {
+                const result = editorOption.applyUpdate(options[editorOption.name], update[editorOption.name]);
+                options[editorOption.name] = result.newValue;
+                changed = changed || result.didChange;
+            }
+        }
+        return changed;
+    }
+}
+export { ComputedEditorOptions, EditorOptionsUtil };

package/dist/vscode/vs/editor/common/services/languageFeaturesService.js

@@ -0,0 +1,41 @@
+import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
+class LanguageFeaturesService {
+    constructor() {
+        this.referenceProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.renameProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.codeActionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.definitionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.typeDefinitionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.declarationProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.implementationProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentSymbolProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.inlayHintsProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.colorProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.codeLensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentFormattingEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentRangeFormattingEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.onTypeFormattingEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.signatureHelpProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.hoverProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentHighlightProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.selectionRangeProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.foldingRangeProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.linkProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.inlineCompletionsProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.completionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.linkedEditingRangeProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.inlineValuesProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.evaluatableExpressionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentRangeSemanticTokensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentSemanticTokensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentOnDropEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentPasteEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+    }
+    setNotebookTypeResolver(resolver) {
+        this._notebookTypeResolver = resolver;
+    }
+    _score(uri) {
+        return this._notebookTypeResolver?.(uri);
+    }
+}
+export { LanguageFeaturesService };

package/dist/vscode/vs/editor/common/services/modelUndoRedoParticipant.js

@@ -0,0 +1,56 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { MultiModelEditStackElement } from 'monaco-editor/esm/vs/editor/common/model/editStack.js';
+let ModelUndoRedoParticipant = class ModelUndoRedoParticipant extends Disposable {
+    constructor(_modelService, _textModelService, _undoRedoService) {
+        super();
+        this._modelService = _modelService;
+        this._textModelService = _textModelService;
+        this._undoRedoService = _undoRedoService;
+        this._register(this._modelService.onModelRemoved((model) => {
+            const elements = this._undoRedoService.getElements(model.uri);
+            if (elements.past.length === 0 && elements.future.length === 0) {
+                return;
+            }
+            for (const element of elements.past) {
+                if (element instanceof MultiModelEditStackElement) {
+                    element.setDelegate(this);
+                }
+            }
+            for (const element of elements.future) {
+                if (element instanceof MultiModelEditStackElement) {
+                    element.setDelegate(this);
+                }
+            }
+        }));
+    }
+    prepareUndoRedo(element) {
+        const missingModels = element.getMissingModels();
+        if (missingModels.length === 0) {
+            return Disposable.None;
+        }
+        const disposablesPromises = ( missingModels.map(async (uri) => {
+            try {
+                const reference = await this._textModelService.createModelReference(uri);
+                return reference;
+            }
+            catch (err) {
+                return Disposable.None;
+            }
+        }));
+        return Promise.all(disposablesPromises).then(disposables => {
+            return {
+                dispose: () => dispose(disposables)
+            };
+        });
+    }
+};
+ModelUndoRedoParticipant = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ITextModelService)),
+    ( __param(2, IUndoRedoService))
+], ModelUndoRedoParticipant));
+export { ModelUndoRedoParticipant };