@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -1,2 +1,2 @@
-export { IExtensionWithExtHostKind, LocalExtHostExtensionService, SimpleExtensionService, WorkerConfig, default, getLocalExtHostExtensionService } from './extensions.js';
+export { ExtensionServiceOverride, IExtensionWithExtHostKind, LocalExtHostExtensionService, WorkerConfig, default, getLocalExtHostExtensionService } from './extensions.js';
 export { ExtensionHostKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';

package/index.js

@@ -1,2 +1,2 @@
-export * from 'vscode/service-override/extensions';
-export { default } from 'vscode/service-override/extensions';
+export { ExtensionServiceOverride, LocalExtHostExtensionService, default, getLocalExtHostExtensionService } from './extensions.js';
+export { ExtensionHostKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,8 @@
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/override/vs/workbench/browser/parts/editor/textEditor.weak.js

@@ -0,0 +1,8 @@
+let AbstractTextEditor = class {};
+class FakeAbstractTextEditor {
+  static [Symbol.hasInstance](instance) {
+      return AbstractTextEditor != null && instance instanceof AbstractTextEditor
+  }
+}
+
+export { FakeAbstractTextEditor as AbstractTextEditor };

package/override/vs/workbench/contrib/notebook/common/notebookEditorInput.js

@@ -0,0 +1,3 @@
+class NotebookEditorInput {}
+
+export { NotebookEditorInput };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-extensions-service-override",
-  "version": "1.83.7",
+  "version": "1.83.9",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,9 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.83.7",
-    "monaco-editor": "0.44.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.9",
+    "monaco-editor": "0.44.0",
+    "vscode-semver": "npm:semver@=5.5.0",
+    "@codingame/monaco-vscode-files-service-override": "1.83.9"
   }
 }

package/tools/url.js

@@ -0,0 +1,10 @@
+function changeUrlDomain(url, domain) {
+    if (domain == null) {
+        return url;
+    }
+    const _url = new URL(url, domain);
+    _url.host = new URL(domain).hostname;
+    return ( _url.toString());
+}
+
+export { changeUrlDomain };

package/tools.js

@@ -0,0 +1,5 @@
+function unsupported() {
+    throw new Error('unsupported');
+}
+
+export { unsupported };

package/vscode/src/vs/base/common/console.js

@@ -0,0 +1,59 @@
+function parse(entry) {
+    const args = [];
+    let stack;
+    try {
+        const parsedArguments = JSON.parse(entry.arguments);
+        const stackArgument = parsedArguments[parsedArguments.length - 1];
+        if (stackArgument && stackArgument.__$stack) {
+            parsedArguments.pop();
+            stack = stackArgument.__$stack;
+        }
+        args.push(...parsedArguments);
+    }
+    catch (error) {
+        args.push('Unable to log remote console arguments', entry.arguments);
+    }
+    return { args, stack };
+}
+function findFirstFrame(stack) {
+    if (!stack) {
+        return stack;
+    }
+    const newlineIndex = stack.indexOf('\n');
+    if (newlineIndex === -1) {
+        return stack;
+    }
+    return stack.substring(0, newlineIndex);
+}
+function log(entry, label) {
+    const { args, stack } = parse(entry);
+    const isOneStringArg = typeof args[0] === 'string' && args.length === 1;
+    let topFrame = findFirstFrame(stack);
+    if (topFrame) {
+        topFrame = `(${topFrame.trim()})`;
+    }
+    let consoleArgs = [];
+    if (typeof args[0] === 'string') {
+        if (topFrame && isOneStringArg) {
+            consoleArgs = [`%c[${label}] %c${args[0]} %c${topFrame}`, color('blue'), color(''), color('grey')];
+        }
+        else {
+            consoleArgs = [`%c[${label}] %c${args[0]}`, color('blue'), color(''), ...args.slice(1)];
+        }
+    }
+    else {
+        consoleArgs = [`%c[${label}]%`, color('blue'), ...args];
+    }
+    if (topFrame && !isOneStringArg) {
+        consoleArgs.push(topFrame);
+    }
+    if (typeof console[entry.severity] !== 'function') {
+        throw new Error('Unknown console method');
+    }
+    console[entry.severity].apply(console, consoleArgs);
+}
+function color(color) {
+    return `color: ${color}`;
+}
+
+export { log, parse };

package/vscode/src/vs/base/common/prefixTree.js

@@ -0,0 +1,131 @@
+const unset = Symbol('unset');
+class WellDefinedPrefixTree {
+    constructor() {
+        this.root = ( new Node());
+        this._size = 0;
+    }
+    get size() {
+        return this._size;
+    }
+    insert(key, value) {
+        this.opNode(key, n => n.value = value);
+    }
+    mutate(key, mutate) {
+        this.opNode(key, n => n.value = mutate(n.value === unset ? undefined : n.value));
+    }
+    delete(key) {
+        const path = [{ part: '', node: this.root }];
+        let i = 0;
+        for (const part of key) {
+            const node = path[i].node.children?.get(part);
+            if (!node) {
+                return undefined;
+            }
+            path.push({ part, node });
+            i++;
+        }
+        const value = path[i].node.value;
+        if (value === unset) {
+            return;
+        }
+        this._size--;
+        for (; i > 0; i--) {
+            const parent = path[i - 1];
+            parent.node.children.delete(path[i].part);
+            if (parent.node.children.size > 0 || parent.node.value !== unset) {
+                break;
+            }
+        }
+        return value;
+    }
+    find(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return undefined;
+            }
+            node = next;
+        }
+        return node.value === unset ? undefined : node.value;
+    }
+    hasKeyOrParent(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            if (next.value !== unset) {
+                return true;
+            }
+            node = next;
+        }
+        return false;
+    }
+    hasKeyOrChildren(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            node = next;
+        }
+        return true;
+    }
+    hasKey(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            node = next;
+        }
+        return node.value !== unset;
+    }
+    opNode(key, fn) {
+        let node = this.root;
+        for (const part of key) {
+            if (!node.children) {
+                const next = ( new Node());
+                node.children = ( new Map([[part, next]]));
+                node = next;
+            }
+            else if (!( node.children.has(part))) {
+                const next = ( new Node());
+                node.children.set(part, next);
+                node = next;
+            }
+            else {
+                node = node.children.get(part);
+            }
+        }
+        if (node.value === unset) {
+            this._size++;
+        }
+        fn(node);
+    }
+    *values() {
+        const stack = [this.root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node.value !== unset) {
+                yield node.value;
+            }
+            if (node.children) {
+                for (const child of ( node.children.values())) {
+                    stack.push(child);
+                }
+            }
+        }
+    }
+}
+class Node {
+    constructor() {
+        this.value = unset;
+    }
+}
+
+export { WellDefinedPrefixTree };

package/vscode/src/vs/platform/files/common/watcher.js

@@ -0,0 +1,71 @@
+import { GLOBSTAR } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
+
+class AbstractWatcherClient extends Disposable {
+    static { this.MAX_RESTARTS = 5; }
+    constructor(onFileChanges, onLogMessage, verboseLogging, options) {
+        super();
+        this.onFileChanges = onFileChanges;
+        this.onLogMessage = onLogMessage;
+        this.verboseLogging = verboseLogging;
+        this.options = options;
+        this.watcherDisposables = this._register(( new MutableDisposable()));
+        this.requests = undefined;
+        this.restartCounter = 0;
+    }
+    init() {
+        const disposables = ( new DisposableStore());
+        this.watcherDisposables.value = disposables;
+        this.watcher = this.createWatcher(disposables);
+        this.watcher.setVerboseLogging(this.verboseLogging);
+        disposables.add(this.watcher.onDidChangeFile(changes => this.onFileChanges(changes)));
+        disposables.add(this.watcher.onDidLogMessage(msg => this.onLogMessage(msg)));
+        disposables.add(this.watcher.onDidError(error => this.onError(error)));
+    }
+    onError(error) {
+        if (this.options.restartOnError) {
+            if (this.restartCounter < AbstractWatcherClient.MAX_RESTARTS && this.requests) {
+                this.error(`restarting watcher after error: ${error}`);
+                this.restart(this.requests);
+            }
+            else {
+                this.error(`gave up attempting to restart watcher after error: ${error}`);
+            }
+        }
+        else {
+            this.error(error);
+        }
+    }
+    restart(requests) {
+        this.restartCounter++;
+        this.init();
+        this.watch(requests);
+    }
+    async watch(requests) {
+        this.requests = requests;
+        await this.watcher?.watch(requests);
+    }
+    async setVerboseLogging(verboseLogging) {
+        this.verboseLogging = verboseLogging;
+        await this.watcher?.setVerboseLogging(verboseLogging);
+    }
+    error(message) {
+        this.onLogMessage({ type: 'error', message: `[File Watcher (${this.options.type})] ${message}` });
+    }
+    trace(message) {
+        this.onLogMessage({ type: 'trace', message: `[File Watcher (${this.options.type})] ${message}` });
+    }
+    dispose() {
+        this.watcher = undefined;
+        return super.dispose();
+    }
+}
+function normalizeWatcherPattern(path, pattern) {
+    if (typeof pattern === 'string' && !pattern.startsWith(GLOBSTAR) && !isAbsolute(pattern)) {
+        return { base: path, pattern };
+    }
+    return pattern;
+}
+
+export { AbstractWatcherClient, normalizeWatcherPattern };

package/vscode/src/vs/platform/lifecycle/common/lifecycle.js

@@ -0,0 +1,27 @@
+import { isThenable, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+
+function handleVetos(vetos, onError) {
+    if (vetos.length === 0) {
+        return Promise.resolve(false);
+    }
+    const promises = [];
+    let lazyValue = false;
+    for (const valueOrPromise of vetos) {
+        if (valueOrPromise === true) {
+            return Promise.resolve(true);
+        }
+        if (isThenable(valueOrPromise)) {
+            promises.push(valueOrPromise.then(value => {
+                if (value) {
+                    lazyValue = true;
+                }
+            }, err => {
+                onError(err);
+                lazyValue = true;
+            }));
+        }
+    }
+    return Promises.settled(promises).then(() => lazyValue);
+}
+
+export { handleVetos };

package/vscode/src/vs/platform/log/browser/log.js

@@ -0,0 +1,26 @@
+import { relativePath } from 'monaco-editor/esm/vs/base/common/resources.js';
+
+async function getLogs(fileService, environmentService) {
+    const result = [];
+    await doGetLogs(fileService, result, environmentService.logsHome, environmentService.logsHome);
+    return result;
+}
+async function doGetLogs(fileService, logs, curFolder, logsHome) {
+    const stat = await fileService.resolve(curFolder);
+    for (const { resource, isDirectory } of stat.children || []) {
+        if (isDirectory) {
+            await doGetLogs(fileService, logs, resource, logsHome);
+        }
+        else {
+            const contents = ( (await fileService.readFile(resource)).value.toString());
+            if (contents) {
+                const path = relativePath(logsHome, resource);
+                if (path) {
+                    logs.push({ relativePath: path, contents });
+                }
+            }
+        }
+    }
+}
+
+export { getLogs };

package/vscode/src/vs/platform/remote/common/managedSocket.js

@@ -0,0 +1,98 @@
+import { VSBuffer, encodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { PauseableEmitter, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { SocketDiagnostics } from 'vscode/vscode/vs/base/parts/ipc/common/ipc.net';
+
+const makeRawSocketHeaders = (path, query, deubgLabel) => {
+    const buffer = ( new Uint8Array(16));
+    for (let i = 0; i < 16; i++) {
+        buffer[i] = Math.round(Math.random() * 256);
+    }
+    const nonce = encodeBase64(VSBuffer.wrap(buffer));
+    const headers = [
+        `GET ws://localhost${path}?${query}&skipWebSocketFrames=true HTTP/1.1`,
+        `Connection: Upgrade`,
+        `Upgrade: websocket`,
+        `Sec-WebSocket-Key: ${nonce}`
+    ];
+    return headers.join('\r\n') + '\r\n\r\n';
+};
+const socketRawEndHeaderSequence = VSBuffer.fromString('\r\n\r\n');
+async function connectManagedSocket(socket, path, query, debugLabel, half) {
+    socket.write(VSBuffer.fromString(makeRawSocketHeaders(path, query)));
+    const d = ( new DisposableStore());
+    try {
+        return await ( new Promise((resolve, reject) => {
+            let dataSoFar;
+            d.add(socket.onData(d_1 => {
+                if (!dataSoFar) {
+                    dataSoFar = d_1;
+                }
+                else {
+                    dataSoFar = VSBuffer.concat([dataSoFar, d_1], dataSoFar.byteLength + d_1.byteLength);
+                }
+                const index = dataSoFar.indexOf(socketRawEndHeaderSequence);
+                if (index === -1) {
+                    return;
+                }
+                resolve(socket);
+                socket.pauseData();
+                const rest = dataSoFar.slice(index + socketRawEndHeaderSequence.byteLength);
+                if (rest.byteLength) {
+                    half.onData.fire(rest);
+                }
+            }));
+            d.add(socket.onClose(err => reject(err ?? ( new Error('socket closed')))));
+            d.add(socket.onEnd(() => reject(( new Error('socket ended')))));
+        }));
+    }
+    catch (e) {
+        socket.dispose();
+        throw e;
+    }
+    finally {
+        d.dispose();
+    }
+}
+class ManagedSocket extends Disposable {
+    constructor(debugLabel, half) {
+        super();
+        this.debugLabel = debugLabel;
+        this.pausableDataEmitter = this._register(( new PauseableEmitter()));
+        this.onData = (...args) => {
+            if (this.pausableDataEmitter.isPaused) {
+                queueMicrotask(() => this.pausableDataEmitter.resume());
+            }
+            return this.pausableDataEmitter.event(...args);
+        };
+        this.didDisposeEmitter = this._register(( new Emitter()));
+        this.onDidDispose = this.didDisposeEmitter.event;
+        this.ended = false;
+        this._register(half.onData);
+        this._register(half.onData.event(data => this.pausableDataEmitter.fire(data)));
+        this.onClose = this._register(half.onClose).event;
+        this.onEnd = this._register(half.onEnd).event;
+    }
+    pauseData() {
+        this.pausableDataEmitter.pause();
+    }
+    drain() {
+        return Promise.resolve();
+    }
+    end() {
+        this.ended = true;
+        this.closeRemote();
+    }
+    traceSocketEvent(type, data) {
+        SocketDiagnostics.traceSocketEvent(this, this.debugLabel, type, data);
+    }
+    dispose() {
+        if (!this.ended) {
+            this.closeRemote();
+        }
+        this.didDisposeEmitter.fire();
+        super.dispose();
+    }
+}
+
+export { ManagedSocket, connectManagedSocket, makeRawSocketHeaders, socketRawEndHeaderSequence };

package/vscode/src/vs/workbench/api/browser/mainThreadAiEmbeddingVector.js

@@ -0,0 +1,31 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IAiEmbeddingVectorService } from 'vscode/vscode/vs/workbench/services/aiEmbeddingVector/common/aiEmbeddingVectorService';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadAiEmbeddingVector = class MainThreadAiEmbeddingVector extends Disposable {
+    constructor(context, _AiEmbeddingVectorService) {
+        super();
+        this._AiEmbeddingVectorService = _AiEmbeddingVectorService;
+        this._registrations = this._register(( new DisposableMap()));
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostAiEmbeddingVector));
+    }
+    $registerAiEmbeddingVectorProvider(model, handle) {
+        const provider = {
+            provideAiEmbeddingVector: (strings, token) => {
+                return this._proxy.$provideAiEmbeddingVector(handle, strings, token);
+            },
+        };
+        this._registrations.set(handle, this._AiEmbeddingVectorService.registerAiEmbeddingVectorProvider(model, provider));
+    }
+    $unregisterAiEmbeddingVectorProvider(handle) {
+        this._registrations.deleteAndDispose(handle);
+    }
+};
+MainThreadAiEmbeddingVector = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadAiEmbeddingVector),
+    ( __param(1, IAiEmbeddingVectorService))
+], MainThreadAiEmbeddingVector);
+
+export { MainThreadAiEmbeddingVector };

package/vscode/src/vs/workbench/api/browser/mainThreadAiRelatedInformation.js

@@ -0,0 +1,35 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IAiRelatedInformationService } from 'vscode/vscode/vs/workbench/services/aiRelatedInformation/common/aiRelatedInformation';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadAiRelatedInformation = class MainThreadAiRelatedInformation extends Disposable {
+    constructor(context, _aiRelatedInformationService) {
+        super();
+        this._aiRelatedInformationService = _aiRelatedInformationService;
+        this._registrations = this._register(( new DisposableMap()));
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostAiRelatedInformation));
+    }
+    $getAiRelatedInformation(query, types) {
+        return this._aiRelatedInformationService.getRelatedInformation(query, types, CancellationToken.None);
+    }
+    $registerAiRelatedInformationProvider(handle, type) {
+        const provider = {
+            provideAiRelatedInformation: (query, token) => {
+                return this._proxy.$provideAiRelatedInformation(handle, query, token);
+            },
+        };
+        this._registrations.set(handle, this._aiRelatedInformationService.registerAiRelatedInformationProvider(type, provider));
+    }
+    $unregisterAiRelatedInformationProvider(handle) {
+        this._registrations.deleteAndDispose(handle);
+    }
+};
+MainThreadAiRelatedInformation = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadAiRelatedInformation),
+    ( __param(1, IAiRelatedInformationService))
+], MainThreadAiRelatedInformation);
+
+export { MainThreadAiRelatedInformation };