monaco-languageclient 9.11.0 → 10.0.0-next.1

package/src/worker/index.ts

@@ -0,0 +1,8 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2025 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+export * from './fakeWorker.js';
+export * from './workerFactory.js';
+export * from './workerLoaders.js';

package/src/{workerFactory.ts → worker/workerFactory.ts}

@@ -3,8 +3,8 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-import { getEnhancedMonacoEnvironment } from 'monaco-languageclient/vscode/services';
-import type { Logger } from 'monaco-languageclient/tools';
+import { getEnhancedMonacoEnvironment } from 'monaco-languageclient/vscodeApiWrapper';
+import type { Logger } from 'monaco-languageclient/common';
 
 export type WorkerLoader = (() => Worker) | undefined;
 

package/src/worker/workerLoaders.ts

@@ -0,0 +1,36 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type { Logger } from 'monaco-languageclient/common';
+import { useWorkerFactory, type WorkerLoader } from 'monaco-languageclient/workerFactory';
+
+export const defineDefaultWorkerLoaders: () => Record<string, WorkerLoader> = () => {
+    const defaultTextEditorWorker = () => new Worker(
+        new URL('@codingame/monaco-vscode-editor-api/esm/vs/editor/editor.worker.js', import.meta.url),
+        { type: 'module' }
+    );
+    const defaultTextMateWorker = () => new Worker(
+        new URL('@codingame/monaco-vscode-textmate-service-override/worker', import.meta.url),
+        { type: 'module' }
+    );
+
+    return {
+        // if you import monaco api as 'monaco-editor': monaco-editor/esm/vs/editor/editor.worker.js
+        TextEditorWorker: defaultTextEditorWorker,
+        TextMateWorker: defaultTextMateWorker,
+        // these are other possible workers not configured by default
+        OutputLinkDetectionWorker: undefined,
+        LanguageDetectionWorker: undefined,
+        NotebookEditorWorker: undefined,
+        LocalFileSearchWorker: undefined
+    };
+};
+
+export const configureDefaultWorkerFactory = (logger?: Logger) => {
+    useWorkerFactory({
+        workerLoaders: defineDefaultWorkerLoaders(),
+        logger
+    });
+};

package/src/wrapper/index.ts

@@ -0,0 +1,8 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+export * from './lcconfig.js';
+export * from './lcmanager.js';
+export * from './lcwrapper.js';

package/src/wrapper/lcconfig.ts

@@ -0,0 +1,32 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2025 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type { LanguageClientOptions, MessageTransports } from 'vscode-languageclient/browser.js';
+import { type ConnectionConfigOptions } from 'monaco-languageclient/common';
+
+export interface ConnectionConfig {
+    options: ConnectionConfigOptions;
+    messageTransports?: MessageTransports;
+}
+
+export interface LanguageClientConfig {
+    name?: string;
+    connection: ConnectionConfig;
+    clientOptions: LanguageClientOptions;
+    restartOptions?: LanguageClientRestartOptions;
+    disposeWorker?: boolean;
+}
+
+export interface LanguageClientRestartOptions {
+    retries: number;
+    timeout: number;
+    keepWorker?: boolean;
+}
+
+export interface LanguageClientConfigs {
+    configs: Record<string, LanguageClientConfig>
+    overwriteExisting?: boolean;
+    enforceDispose?: boolean;
+}

package/src/wrapper/lcmanager.ts

@@ -0,0 +1,89 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2025 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type { Logger } from 'monaco-languageclient/common';
+import type { LanguageClientConfigs } from './lcconfig.js';
+import { LanguageClientWrapper } from './lcwrapper.js';
+
+export class LanguageClientsManager {
+
+    private logger?: Logger;
+    private languageClientConfigs?: LanguageClientConfigs;
+    private languageClientWrappers: Map<string, LanguageClientWrapper> = new Map();
+
+    constructor(logger?: Logger) {
+        this.logger = logger;
+    }
+
+    haveLanguageClients(): boolean {
+        return this.languageClientWrappers.size > 0;
+    }
+
+    getLanguageClientWrapper(languageId: string): LanguageClientWrapper | undefined {
+        return this.languageClientWrappers.get(languageId);
+    }
+
+    getLanguageClient(languageId: string) {
+        return this.languageClientWrappers.get(languageId)?.getLanguageClient();
+    }
+
+    getWorker(languageId: string): Worker | undefined {
+        return this.languageClientWrappers.get(languageId)?.getWorker();
+    }
+
+    async setConfigs(languageClientConfigs: LanguageClientConfigs): Promise<void> {
+        this.languageClientConfigs = languageClientConfigs;
+
+        const lccEntries = Object.entries(this.languageClientConfigs.configs);
+        if (lccEntries.length > 0) {
+            for (const [languageId, lcc] of lccEntries) {
+                const current = this.languageClientWrappers.get(languageId);
+                const lcw = new LanguageClientWrapper(lcc, this.logger);
+
+                if (current !== undefined) {
+                    if (languageClientConfigs.overwriteExisting === true) {
+                        if (languageClientConfigs.enforceDispose === true) {
+                            await current.dispose();
+                        }
+                    } else {
+                        throw new Error(`A languageclient config with id "${languageId}" already exists and you confiured to not override.`);
+                    }
+                }
+                this.languageClientWrappers.set(languageId, lcw);
+            }
+        }
+    }
+
+    async start(): Promise<void | void[]> {
+        const allPromises: Array<Promise<void>> = [];
+        for (const lcw of this.languageClientWrappers.values()) {
+            if (!lcw.isStarted()) {
+                allPromises.push(lcw.start());
+            }
+        }
+        return Promise.all(allPromises);
+    }
+
+    isStarted(): boolean {
+        for (const lcw of this.languageClientWrappers.values()) {
+            // as soon as one is not started return
+            if (!lcw.isStarted()) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    async dispose(): Promise<void | void[]> {
+        const allPromises: Array<Promise<void>> = [];
+        for (const lcw of this.languageClientWrappers.values()) {
+            if (lcw.haveLanguageClient()) {
+                allPromises.push(lcw.dispose());
+            }
+        }
+        await Promise.all(allPromises);
+        this.languageClientWrappers.clear();
+    }
+}

package/src/wrapper/lcwrapper.ts

@@ -0,0 +1,280 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageserver-protocol/browser.js';
+import { CloseAction, ErrorAction, MessageTransports, State } from 'vscode-languageclient/browser.js';
+import { createUrl, type Logger, type WorkerConfigOptionsDirect, type WorkerConfigOptionsParams } from 'monaco-languageclient/common';
+import { toSocket, WebSocketMessageReader, WebSocketMessageWriter } from 'vscode-ws-jsonrpc';
+import { MonacoLanguageClient } from 'monaco-languageclient';
+import type { LanguageClientConfig, LanguageClientRestartOptions } from './lcconfig.js';
+
+export interface LanguageClientError {
+    message: string;
+    error: Error | string;
+}
+
+export class LanguageClientWrapper {
+
+    private languageClient?: MonacoLanguageClient;
+    private languageClientConfig: LanguageClientConfig;
+    private worker?: Worker;
+    private port?: MessagePort;
+    private name?: string;
+    private logger: Logger | undefined;
+
+    constructor(config: LanguageClientConfig, logger?: Logger) {
+        this.languageClientConfig = config;
+        this.name = this.languageClientConfig.name ?? 'unnamed';
+        this.logger = logger;
+    }
+
+    haveLanguageClient(): boolean {
+        return this.languageClient !== undefined;
+    }
+
+    getLanguageClient(): MonacoLanguageClient | undefined {
+        return this.languageClient;
+    }
+
+    getWorker(): Worker | undefined {
+        return this.worker;
+    }
+
+    isStarted(): boolean {
+        return this.languageClient !== undefined && this.languageClient.isRunning();
+    }
+
+    async start(): Promise<void> {
+        if (this.languageClient?.isRunning() ?? false) {
+            this.logger?.info('startLanguageClientConnection: monaco-languageclient already running!');
+            return Promise.resolve();
+        }
+
+        return new Promise((resolve, reject) => {
+            const conConfig = this.languageClientConfig.connection;
+            const conOptions = conConfig.options;
+
+            if (conOptions.$type === 'WebSocketDirect' || conOptions.$type === 'WebSocketParams' || conOptions.$type === 'WebSocketUrl') {
+                const webSocket = conOptions.$type === 'WebSocketDirect' ? conOptions.webSocket : new WebSocket(createUrl(conOptions));
+                this.initMessageTransportWebSocket(webSocket, resolve, reject);
+            } else {
+                // init of worker and start of languageclient can be handled directly, because worker available already
+                this.initMessageTransportWorker(conOptions, resolve, reject);
+            }
+        });
+    }
+
+    /**
+     * Restart the languageclient with options to control worker handling
+     *
+     * @param updatedWorker Set a new worker here that should be used. keepWorker has no effect then, as we want to dispose of the prior workers
+     * @param disposeWorker Set to false if worker should not be disposed
+     */
+    async restart(updatedWorker?: Worker, forceWorkerDispose?: boolean): Promise<void> {
+        await this.dispose(forceWorkerDispose);
+
+        this.worker = updatedWorker;
+        this.logger?.info('Re-Starting monaco-languageclient');
+        return this.start();
+    }
+
+    protected async initMessageTransportWebSocket(webSocket: WebSocket, resolve: () => void, reject: (reason?: unknown) => void) {
+
+        let messageTransports = this.languageClientConfig.connection.messageTransports;
+        if (messageTransports === undefined) {
+            const iWebSocket = toSocket(webSocket);
+            messageTransports = {
+                reader: new WebSocketMessageReader(iWebSocket),
+                writer: new WebSocketMessageWriter(iWebSocket)
+            };
+        }
+
+        // if websocket is already open, then start the languageclient directly
+        if (webSocket.readyState === WebSocket.OPEN) {
+            await this.performLanguageClientStart(messageTransports, resolve, reject);
+        }
+
+        // otherwise start on open
+        webSocket.onopen = async () => {
+            await this.performLanguageClientStart(messageTransports, resolve, reject);
+        };
+        webSocket.onerror = (ev: Event) => {
+            const languageClientError: LanguageClientError = {
+                message: `languageClientWrapper (${this.name}): Websocket connection failed.`,
+                error: (ev as ErrorEvent).error ?? 'No error was provided.'
+            };
+            reject(languageClientError);
+        };
+    }
+
+    protected async initMessageTransportWorker(lccOptions: WorkerConfigOptionsDirect | WorkerConfigOptionsParams, resolve: () => void, reject: (reason?: unknown) => void) {
+        if (!this.worker) {
+            if (lccOptions.$type === 'WorkerConfig') {
+                const workerConfig = lccOptions as WorkerConfigOptionsParams;
+                this.worker = new Worker(workerConfig.url.href, {
+                    type: workerConfig.type,
+                    name: workerConfig.workerName
+                });
+
+                this.worker.onerror = (ev) => {
+                    const languageClientError: LanguageClientError = {
+                        message: `languageClientWrapper (${this.name}): Illegal worker configuration detected.`,
+                        error: ev.error ?? 'No error was provided.'
+                    };
+                    reject(languageClientError);
+                };
+            } else {
+                const workerDirectConfig = lccOptions as WorkerConfigOptionsDirect;
+                this.worker = workerDirectConfig.worker;
+            }
+            if (lccOptions.messagePort !== undefined) {
+                this.port = lccOptions.messagePort;
+            }
+        }
+
+        const portOrWorker = this.port ? this.port : this.worker;
+        let messageTransports = this.languageClientConfig.connection.messageTransports;
+        if (messageTransports === undefined) {
+            messageTransports = {
+                reader: new BrowserMessageReader(portOrWorker),
+                writer: new BrowserMessageWriter(portOrWorker)
+            };
+        }
+
+        await this.performLanguageClientStart(messageTransports, resolve, reject);
+    }
+
+    protected async performLanguageClientStart(messageTransports: MessageTransports, resolve: () => void, reject: (reason?: unknown) => void) {
+        let starting = true;
+        // do not perform another start attempt if already running
+        if (this.languageClient?.isRunning() ?? false) {
+            this.logger?.info('performLanguageClientStart: monaco-languageclient already running!');
+            resolve();
+        }
+
+        const mlcConfig = {
+            name: this.languageClientConfig.name ?? 'Monaco Wrapper Language Client',
+            clientOptions: {
+                // disable the default error handler...
+                errorHandler: {
+                    error: (e: Error) => {
+                        if (starting) {
+                            reject(`Error occurred in language client: ${e}`);
+                            return { action: ErrorAction.Shutdown };
+                        } else {
+                            return { action: ErrorAction.Continue };
+                        }
+                    },
+                    closed: () => ({ action: CloseAction.DoNotRestart })
+                },
+                // ...but allowm to override all options
+                ...this.languageClientConfig.clientOptions,
+            },
+            messageTransports
+        };
+        this.languageClient = new MonacoLanguageClient(mlcConfig);
+
+        const conOptions = this.languageClientConfig.connection.options;
+        this.initRestartConfiguration(messageTransports, this.languageClientConfig.restartOptions);
+
+        const isWebSocket = conOptions.$type === 'WebSocketParams' || conOptions.$type === 'WebSocketUrl' || conOptions.$type === 'WebSocketDirect';
+
+        messageTransports.reader.onClose(async () => {
+            await this.languageClient?.stop();
+
+            if (isWebSocket && conOptions.stopOptions !== undefined) {
+                const stopOptions = conOptions.stopOptions;
+                stopOptions.onCall(this.getLanguageClient());
+                if (stopOptions.reportStatus !== undefined) {
+                    this.logger?.info(this.reportStatus().join('\n'));
+                }
+            }
+        });
+
+        try {
+            await this.languageClient.start();
+
+            if (isWebSocket && conOptions.startOptions !== undefined) {
+                const startOptions = conOptions.startOptions;
+                startOptions.onCall(this.getLanguageClient());
+                if (startOptions.reportStatus !== undefined) {
+                    this.logger?.info(this.reportStatus().join('\n'));
+                }
+            }
+        } catch (e: unknown) {
+            const languageClientError: LanguageClientError = {
+                message: `languageClientWrapper (${this.name}): Start was unsuccessful.`,
+                error: Object.hasOwn(e ?? {}, 'cause') ? (e as Error) : 'No error was provided.'
+            };
+            reject(languageClientError);
+        }
+        this.logger?.info(`languageClientWrapper (${this.name}): Started successfully.`);
+        resolve();
+        starting = false;
+    }
+
+    protected initRestartConfiguration(messageTransports: MessageTransports, restartOptions?: LanguageClientRestartOptions) {
+        if (restartOptions !== undefined) {
+            let retry = 0;
+
+            const readerOnError = messageTransports.reader.onError(() => restartLC);
+            const readerOnClose = messageTransports.reader.onClose(() => restartLC);
+
+            const restartLC = async () => {
+                if (this.isStarted()) {
+                    try {
+                        readerOnError.dispose();
+                        readerOnClose.dispose();
+
+                        await this.restart(this.worker, restartOptions.keepWorker);
+                    } finally {
+                        retry++;
+                        if (retry > (restartOptions.retries) && !this.isStarted()) {
+                            this.logger?.info(`Disabling Language Client. Failed to start clangd after ${restartOptions.retries} retries`);
+                        } else {
+                            setTimeout(async () => {
+                                await this.restart(this.worker, restartOptions.keepWorker);
+                            }, restartOptions.timeout);
+                        }
+                    }
+                }
+            };
+        }
+    }
+
+    protected disposeWorker() {
+        this.worker?.terminate();
+        this.worker = undefined;
+    }
+
+    async dispose(forceWorkerDispose?: boolean): Promise<void> {
+        try {
+            if (this.isStarted()) {
+                await this.languageClient?.dispose();
+                this.languageClient = undefined;
+                this.logger?.info('monaco-languageclient and monaco-editor were successfully disposed.');
+            }
+        } catch (e) {
+            const languageClientError: LanguageClientError = {
+                message: `languageClientWrapper (${this.name}): Disposing the monaco-languageclient resulted in error.`,
+                error: Object.hasOwn(e ?? {}, 'cause') ? (e as Error) : 'No error was provided.'
+            };
+            return Promise.reject(languageClientError);
+        } finally {
+            // always terminate the worker if desired
+            if (this.languageClientConfig.disposeWorker === true || forceWorkerDispose === true) {
+                this.disposeWorker();
+            }
+        }
+    }
+
+    reportStatus() {
+        const status: string[] = [];
+        const languageClient = this.getLanguageClient();
+        status.push('LanguageClientWrapper status:');
+        status.push(`LanguageClient: ${languageClient?.name ?? 'Language Client'} is in a '${State[languageClient?.state ?? 1]}' state`);
+        return status;
+    }
+}

package/lib/client.d.ts

@@ -1,13 +0,0 @@
-import { BaseLanguageClient, MessageTransports, type LanguageClientOptions } from 'vscode-languageclient/browser.js';
-export type MonacoLanguageClientOptions = {
-    name: string;
-    id?: string;
-    clientOptions: LanguageClientOptions;
-    messageTransports: MessageTransports;
-};
-export declare class MonacoLanguageClient extends BaseLanguageClient {
-    protected readonly messageTransports: MessageTransports;
-    constructor({ id, name, clientOptions, messageTransports }: MonacoLanguageClientOptions);
-    protected createMessageTransports(_encoding: string): Promise<MessageTransports>;
-}
-//# sourceMappingURL=client.d.ts.map

package/lib/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,KAAK,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAErH,MAAM,MAAM,2BAA2B,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,qBAAqB,CAAC;IACrC,iBAAiB,EAAE,iBAAiB,CAAC;CACxC,CAAA;AAED,qBAAa,oBAAqB,SAAQ,kBAAkB;IACxD,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;gBAE5C,EAAE,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,iBAAiB,EAAE,EAAE,2BAA2B;cAKpE,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAG5F"}

package/lib/client.js

@@ -1,16 +0,0 @@
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) 2024 TypeFox and others.
- * Licensed under the MIT License. See LICENSE in the package root for license information.
- * ------------------------------------------------------------------------------------------ */
-import { BaseLanguageClient, MessageTransports } from 'vscode-languageclient/browser.js';
-export class MonacoLanguageClient extends BaseLanguageClient {
-    messageTransports;
-    constructor({ id, name, clientOptions, messageTransports }) {
-        super(id ?? name.toLowerCase(), name, clientOptions);
-        this.messageTransports = messageTransports;
-    }
-    createMessageTransports(_encoding) {
-        return Promise.resolve(this.messageTransports);
-    }
-}
-//# sourceMappingURL=client.js.map

package/lib/client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAA8B,MAAM,kCAAkC,CAAC;AASrH,MAAM,OAAO,oBAAqB,SAAQ,kBAAkB;IACrC,iBAAiB,CAAoB;IAExD,YAAY,EAAE,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,iBAAiB,EAA+B;QACnF,KAAK,CAAC,EAAE,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC;QACrD,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;IAC/C,CAAC;IAEkB,uBAAuB,CAAC,SAAiB;QACxD,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACnD,CAAC;CACJ"}

package/lib/commonTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"commonTypes.d.ts","sourceRoot":"","sources":["../src/commonTypes.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,uBAAuB,GAAG,4BAA4B,GAAG,4BAA4B,GAAG,yBAAyB,GAAG,yBAAyB,GAAG,yBAAyB,CAAC;AAEtL,MAAM,WAAW,oBAAoB;IACjC,oCAAoC;IACpC,MAAM,EAAE,CAAC,cAAc,CAAC,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACxD,wCAAwC;IACxC,YAAY,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,4BAA4B;IACzC,KAAK,EAAE,iBAAiB,CAAA;IACxB,SAAS,EAAE,SAAS,CAAA;IACpB,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;CAC1E;AAED,MAAM,WAAW,4BAA6B,SAAQ,kBAAkB;IACpE,KAAK,EAAE,iBAAiB,CAAA;IACxB,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IAC/B,GAAG,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,yBAA0B,SAAQ,kBAAkB;IACjE,KAAK,EAAE,cAAc,CAAA;IACrB,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACtC;AAED,MAAM,WAAW,yBAAyB;IACtC,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,GAAG,CAAC;IACT,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC3B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,yBAAyB;IACtC,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,WAAW,CAAC;CAC7B"}

package/lib/commonTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"commonTypes.js","sourceRoot":"","sources":["../src/commonTypes.ts"],"names":[],"mappings":"AAAA;;;gGAGgG"}

package/lib/tools/index.d.ts

@@ -1,3 +0,0 @@
-export * from './logging.js';
-export * from './utils.js';
-//# sourceMappingURL=index.d.ts.map

package/lib/tools/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAKA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/lib/tools/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/lib/tools/logging.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../src/tools/logging.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,IAAI,mBAAmB,EAAE,KAAK,OAAO,EAAE,MAAM,+CAA+C,CAAC;AACnH,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAExD,MAAM,WAAW,MAAO,SAAQ,OAAO;IACnC,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;CACnE;AAED,qBAAa,aAAc,SAAQ,mBAAmB;gBAEtC,QAAQ,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,OAAO;IAIpD,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE;CAO1D"}

package/lib/tools/logging.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"logging.js","sourceRoot":"","sources":["../../src/tools/logging.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,OAAO,EAAE,aAAa,IAAI,mBAAmB,EAAgB,MAAM,+CAA+C,CAAC;AACnH,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAMxD,MAAM,OAAO,aAAc,SAAQ,mBAAmB;IAElD,YAAY,QAAmB,EAAE,SAAmB;QAChD,KAAK,CAAC,QAAQ,IAAI,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IAC/C,CAAC;IAED,iBAAiB,CAAC,OAAe,EAAE,GAAG,MAAiB;QACnD,IAAI,IAAI,CAAC,QAAQ,EAAE,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;YACpC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,MAAM,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;CAEJ"}

package/lib/tools/utils.d.ts

@@ -1,3 +0,0 @@
-import type { WebSocketUrlParams, WebSocketUrlString } from 'monaco-languageclient';
-export declare const createUrl: (config: WebSocketUrlParams | WebSocketUrlString) => string;
-//# sourceMappingURL=utils.d.ts.map

package/lib/tools/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/tools/utils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEpF,eAAO,MAAM,SAAS,GAAI,QAAQ,kBAAkB,GAAG,kBAAkB,WA+BxE,CAAC"}

package/lib/tools/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/tools/utils.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAIhG,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,MAA+C,EAAE,EAAE;IACzE,IAAI,QAAQ,GAAG,EAAE,CAAC;IAClB,IAAK,MAA6B,CAAC,GAAG,EAAE,CAAC;QACrC,MAAM,OAAO,GAAG,MAA4B,CAAC;QAC7C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACxE,MAAM,IAAI,KAAK,CAAC,uCAAuC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QAC1E,CAAC;QACD,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAC3B,CAAC;SAAM,CAAC;QACJ,MAAM,OAAO,GAAG,MAA4B,CAAC;QAC7C,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;QAChD,QAAQ,GAAG,GAAG,QAAQ,MAAM,OAAO,CAAC,IAAI,EAAE,CAAC;QAC3C,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,OAAO,CAAC,IAAI,KAAK,EAAE,EAAE,CAAC;gBACtB,QAAQ,IAAI,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;YACnC,CAAC;QACL,CAAC;QACD,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,QAAQ,IAAI,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACnC,CAAC;QACD,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YACtB,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;YAE9B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC7D,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC3F,CAAC;YAED,QAAQ,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;QAC9B,CAAC;IACL,CAAC;IACD,OAAO,QAAQ,CAAC;AACpB,CAAC,CAAC"}

package/lib/vscode/services.d.ts

@@ -1,64 +0,0 @@
-import * as monaco from '@codingame/monaco-vscode-editor-api';
-import 'vscode/localExtensionHost';
-import { type IWorkbenchConstructionOptions } from '@codingame/monaco-vscode-api';
-import type { OpenEditor } from '@codingame/monaco-vscode-editor-service-override';
-import type { LocalizationOptions } from '@codingame/monaco-vscode-localization-service-override';
-import type { EnvironmentOverride } from '@codingame/monaco-vscode-api/workbench';
-import type { Logger } from 'monaco-languageclient/tools';
-export interface MonacoEnvironmentEnhanced extends monaco.Environment {
-    vscodeInitialising?: boolean;
-    vscodeApiInitialised?: boolean;
-}
-export interface UserConfiguration {
-    json?: string;
-}
-export interface ViewsConfig {
-    viewServiceType: 'EditorService' | 'ViewsService' | 'WorkspaceService';
-    openEditorFunc?: OpenEditor;
-    htmlAugmentationInstructions?: (htmlContainer: HTMLElement | null | undefined) => void;
-    viewsInitFunc?: () => Promise<void>;
-}
-export interface VscodeApiConfig {
-    vscodeApiInitPerformExternally?: boolean;
-    loadThemes?: boolean;
-    serviceOverrides?: monaco.editor.IEditorOverrideServices;
-    enableExtHostWorker?: boolean;
-    workspaceConfig?: IWorkbenchConstructionOptions;
-    userConfiguration?: UserConfiguration;
-    viewsConfig?: ViewsConfig;
-    envOptions?: EnvironmentOverride;
-}
-export interface InitServicesInstructions {
-    htmlContainer?: HTMLElement;
-    caller?: string;
-    performServiceConsistencyChecks?: () => boolean;
-    logger?: Logger;
-    monacoWorkerFactory?: (logger?: Logger) => void;
-}
-export declare const getEnhancedMonacoEnvironment: () => MonacoEnvironmentEnhanced;
-export declare const getMonacoEnvironmentEnhanced: () => MonacoEnvironmentEnhanced;
-export declare const supplyRequiredServices: () => Promise<{
-    [x: string]: any;
-}>;
-export declare const reportServiceLoading: (services: monaco.editor.IEditorOverrideServices, logger?: Logger) => void;
-export declare const mergeServices: (overrideServices: monaco.editor.IEditorOverrideServices, services?: monaco.editor.IEditorOverrideServices) => void;
-export declare const initServices: (vscodeApiConfig: VscodeApiConfig, instructions?: InitServicesInstructions) => Promise<boolean | undefined>;
-/**
- * monaco-vscode-api automatically loads the following services:
- *  - layout
- *  - environment
- *  - extension
- *  - files
- *  - quickAccess
- * monaco-languageclient always adds the following services:
- *   - languages
- *   - log
- *   - model
- */
-export declare const importAllServices: (vscodeApiConfig: VscodeApiConfig, instructions?: InitServicesInstructions) => Promise<void>;
-/**
- * Enable ext host to run in a worker
- */
-export declare const configureExtHostWorker: (enableExtHostWorker: boolean, userServices: monaco.editor.IEditorOverrideServices) => Promise<void>;
-export declare const createDefaultLocaleConfiguration: () => LocalizationOptions;
-//# sourceMappingURL=services.d.ts.map

package/lib/vscode/services.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/vscode/services.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,MAAM,qCAAqC,CAAC;AAC9D,OAAO,2BAA2B,CAAC;AACnC,OAAO,EAAc,KAAK,6BAA6B,EAAE,MAAM,8BAA8B,CAAC;AAC9F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kDAAkD,CAAC;AAOnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wDAAwD,CAAC;AAClG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAK1D,MAAM,WAAW,yBAA0B,SAAQ,MAAM,CAAC,WAAW;IACjE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AACD,MAAM,WAAW,WAAW;IACxB,eAAe,EAAE,eAAe,GAAG,cAAc,GAAG,kBAAkB,CAAC;IACvE,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,4BAA4B,CAAC,EAAE,CAAC,aAAa,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,KAAK,IAAI,CAAC;IACvF,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,eAAe;IAC5B,8BAA8B,CAAC,EAAE,OAAO,CAAC;IACzC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,uBAAuB,CAAC;IACzD,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,eAAe,CAAC,EAAE,6BAA6B,CAAC;IAChD,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,UAAU,CAAC,EAAE,mBAAmB,CAAC;CACpC;AAED,MAAM,WAAW,wBAAwB;IACrC,aAAa,CAAC,EAAE,WAAW,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+BAA+B,CAAC,EAAE,MAAM,OAAO,CAAC;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CACnD;AAED,eAAO,MAAM,4BAA4B,QAAO,yBAc/C,CAAC;AAEF,eAAO,MAAM,4BAA4B,QAEF,yBACtC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;EAOlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM,CAAC,MAAM,CAAC,uBAAuB,EAAE,SAAS,MAAM,SAIpG,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,kBAAkB,MAAM,CAAC,MAAM,CAAC,uBAAuB,EAAE,WAAW,MAAM,CAAC,MAAM,CAAC,uBAAuB,SAMtI,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,iBAAiB,eAAe,EAAE,eAAe,wBAAwB,iCAiC3G,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,GAAU,iBAAiB,eAAe,EAAE,eAAe,wBAAwB,kBAoBhH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GAAU,qBAAqB,OAAO,EAAE,cAAc,MAAM,CAAC,MAAM,CAAC,uBAAuB,kBAY7H,CAAC;AAEF,eAAO,MAAM,gCAAgC,QAAO,mBA8DnD,CAAC"}