@cardstack/boxel-cli 0.3.2-unstable.59 → 0.3.2-unstable.60

package/bundled-test-harness/assets/tsMode-oJEHe-CR.js

@@ -0,0 +1,968 @@
+import "./chunk-CGdGNDIi.js";
+import { m as editor_api_exports } from "./editor.api-C-6J5J7V.js";
+import { l as typescriptDefaults } from "./monaco.contribution-yXcOyzue.js";
+//#region ../../node_modules/.pnpm/monaco-editor@0.52.2_patch_hash=bdefe071221b87c7c15e1add6739d24d486f543dbad0d714ae586085204626cd/node_modules/monaco-editor/esm/vs/language/typescript/tsMode.js
+/*!-----------------------------------------------------------------------------
+* Copyright (c) Microsoft Corporation. All rights reserved.
+* Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+* Released under the MIT license
+* https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+*-----------------------------------------------------------------------------*/
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var monaco_editor_core_exports = {};
+__reExport(monaco_editor_core_exports, editor_api_exports);
+var WorkerManager = class {
+	constructor(_modeId, _defaults) {
+		this._modeId = _modeId;
+		this._defaults = _defaults;
+		this._worker = null;
+		this._client = null;
+		this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
+		this._updateExtraLibsToken = 0;
+		this._extraLibsChangeListener = this._defaults.onDidExtraLibsChange(() => this._updateExtraLibs());
+	}
+	dispose() {
+		this._configChangeListener.dispose();
+		this._extraLibsChangeListener.dispose();
+		this._stopWorker();
+	}
+	_stopWorker() {
+		if (this._worker) {
+			this._worker.dispose();
+			this._worker = null;
+		}
+		this._client = null;
+	}
+	async _updateExtraLibs() {
+		if (!this._worker) return;
+		const myToken = ++this._updateExtraLibsToken;
+		const proxy = await this._worker.getProxy();
+		if (this._updateExtraLibsToken !== myToken) return;
+		proxy.updateExtraLibs(this._defaults.getExtraLibs());
+	}
+	_getClient() {
+		if (!this._client) this._client = (async () => {
+			this._worker = monaco_editor_core_exports.editor.createWebWorker({
+				moduleId: "vs/language/typescript/tsWorker",
+				label: this._modeId,
+				keepIdleModels: true,
+				createData: {
+					compilerOptions: this._defaults.getCompilerOptions(),
+					extraLibs: this._defaults.getExtraLibs(),
+					customWorkerPath: this._defaults.workerOptions.customWorkerPath,
+					inlayHintsOptions: this._defaults.inlayHintsOptions
+				}
+			});
+			if (this._defaults.getEagerModelSync()) return await this._worker.withSyncedResources(monaco_editor_core_exports.editor.getModels().filter((model) => model.getLanguageId() === this._modeId).map((model) => model.uri));
+			return await this._worker.getProxy();
+		})();
+		return this._client;
+	}
+	async getLanguageServiceWorker(...resources) {
+		const client = await this._getClient();
+		if (this._worker) await this._worker.withSyncedResources(resources);
+		return client;
+	}
+};
+var libFileSet = {};
+libFileSet["lib.d.ts"] = true;
+libFileSet["lib.decorators.d.ts"] = true;
+libFileSet["lib.decorators.legacy.d.ts"] = true;
+libFileSet["lib.dom.asynciterable.d.ts"] = true;
+libFileSet["lib.dom.d.ts"] = true;
+libFileSet["lib.dom.iterable.d.ts"] = true;
+libFileSet["lib.es2015.collection.d.ts"] = true;
+libFileSet["lib.es2015.core.d.ts"] = true;
+libFileSet["lib.es2015.d.ts"] = true;
+libFileSet["lib.es2015.generator.d.ts"] = true;
+libFileSet["lib.es2015.iterable.d.ts"] = true;
+libFileSet["lib.es2015.promise.d.ts"] = true;
+libFileSet["lib.es2015.proxy.d.ts"] = true;
+libFileSet["lib.es2015.reflect.d.ts"] = true;
+libFileSet["lib.es2015.symbol.d.ts"] = true;
+libFileSet["lib.es2015.symbol.wellknown.d.ts"] = true;
+libFileSet["lib.es2016.array.include.d.ts"] = true;
+libFileSet["lib.es2016.d.ts"] = true;
+libFileSet["lib.es2016.full.d.ts"] = true;
+libFileSet["lib.es2016.intl.d.ts"] = true;
+libFileSet["lib.es2017.d.ts"] = true;
+libFileSet["lib.es2017.date.d.ts"] = true;
+libFileSet["lib.es2017.full.d.ts"] = true;
+libFileSet["lib.es2017.intl.d.ts"] = true;
+libFileSet["lib.es2017.object.d.ts"] = true;
+libFileSet["lib.es2017.sharedmemory.d.ts"] = true;
+libFileSet["lib.es2017.string.d.ts"] = true;
+libFileSet["lib.es2017.typedarrays.d.ts"] = true;
+libFileSet["lib.es2018.asyncgenerator.d.ts"] = true;
+libFileSet["lib.es2018.asynciterable.d.ts"] = true;
+libFileSet["lib.es2018.d.ts"] = true;
+libFileSet["lib.es2018.full.d.ts"] = true;
+libFileSet["lib.es2018.intl.d.ts"] = true;
+libFileSet["lib.es2018.promise.d.ts"] = true;
+libFileSet["lib.es2018.regexp.d.ts"] = true;
+libFileSet["lib.es2019.array.d.ts"] = true;
+libFileSet["lib.es2019.d.ts"] = true;
+libFileSet["lib.es2019.full.d.ts"] = true;
+libFileSet["lib.es2019.intl.d.ts"] = true;
+libFileSet["lib.es2019.object.d.ts"] = true;
+libFileSet["lib.es2019.string.d.ts"] = true;
+libFileSet["lib.es2019.symbol.d.ts"] = true;
+libFileSet["lib.es2020.bigint.d.ts"] = true;
+libFileSet["lib.es2020.d.ts"] = true;
+libFileSet["lib.es2020.date.d.ts"] = true;
+libFileSet["lib.es2020.full.d.ts"] = true;
+libFileSet["lib.es2020.intl.d.ts"] = true;
+libFileSet["lib.es2020.number.d.ts"] = true;
+libFileSet["lib.es2020.promise.d.ts"] = true;
+libFileSet["lib.es2020.sharedmemory.d.ts"] = true;
+libFileSet["lib.es2020.string.d.ts"] = true;
+libFileSet["lib.es2020.symbol.wellknown.d.ts"] = true;
+libFileSet["lib.es2021.d.ts"] = true;
+libFileSet["lib.es2021.full.d.ts"] = true;
+libFileSet["lib.es2021.intl.d.ts"] = true;
+libFileSet["lib.es2021.promise.d.ts"] = true;
+libFileSet["lib.es2021.string.d.ts"] = true;
+libFileSet["lib.es2021.weakref.d.ts"] = true;
+libFileSet["lib.es2022.array.d.ts"] = true;
+libFileSet["lib.es2022.d.ts"] = true;
+libFileSet["lib.es2022.error.d.ts"] = true;
+libFileSet["lib.es2022.full.d.ts"] = true;
+libFileSet["lib.es2022.intl.d.ts"] = true;
+libFileSet["lib.es2022.object.d.ts"] = true;
+libFileSet["lib.es2022.regexp.d.ts"] = true;
+libFileSet["lib.es2022.sharedmemory.d.ts"] = true;
+libFileSet["lib.es2022.string.d.ts"] = true;
+libFileSet["lib.es2023.array.d.ts"] = true;
+libFileSet["lib.es2023.collection.d.ts"] = true;
+libFileSet["lib.es2023.d.ts"] = true;
+libFileSet["lib.es2023.full.d.ts"] = true;
+libFileSet["lib.es5.d.ts"] = true;
+libFileSet["lib.es6.d.ts"] = true;
+libFileSet["lib.esnext.collection.d.ts"] = true;
+libFileSet["lib.esnext.d.ts"] = true;
+libFileSet["lib.esnext.decorators.d.ts"] = true;
+libFileSet["lib.esnext.disposable.d.ts"] = true;
+libFileSet["lib.esnext.full.d.ts"] = true;
+libFileSet["lib.esnext.intl.d.ts"] = true;
+libFileSet["lib.esnext.object.d.ts"] = true;
+libFileSet["lib.esnext.promise.d.ts"] = true;
+libFileSet["lib.scripthost.d.ts"] = true;
+libFileSet["lib.webworker.asynciterable.d.ts"] = true;
+libFileSet["lib.webworker.d.ts"] = true;
+libFileSet["lib.webworker.importscripts.d.ts"] = true;
+libFileSet["lib.webworker.iterable.d.ts"] = true;
+function flattenDiagnosticMessageText(diag, newLine, indent = 0) {
+	if (typeof diag === "string") return diag;
+	else if (diag === void 0) return "";
+	let result = "";
+	if (indent) {
+		result += newLine;
+		for (let i = 0; i < indent; i++) result += "  ";
+	}
+	result += diag.messageText;
+	indent++;
+	if (diag.next) for (const kid of diag.next) result += flattenDiagnosticMessageText(kid, newLine, indent);
+	return result;
+}
+function displayPartsToString(displayParts) {
+	if (displayParts) return displayParts.map((displayPart) => displayPart.text).join("");
+	return "";
+}
+var Adapter = class {
+	constructor(_worker) {
+		this._worker = _worker;
+	}
+	_textSpanToRange(model, span) {
+		let p1 = model.getPositionAt(span.start);
+		let p2 = model.getPositionAt(span.start + span.length);
+		let { lineNumber: startLineNumber, column: startColumn } = p1;
+		let { lineNumber: endLineNumber, column: endColumn } = p2;
+		return {
+			startLineNumber,
+			startColumn,
+			endLineNumber,
+			endColumn
+		};
+	}
+};
+var LibFiles = class {
+	constructor(_worker) {
+		this._worker = _worker;
+		this._libFiles = {};
+		this._hasFetchedLibFiles = false;
+		this._fetchLibFilesPromise = null;
+	}
+	isLibFile(uri) {
+		if (!uri) return false;
+		if (uri.path.indexOf("/lib.") === 0) return !!libFileSet[uri.path.slice(1)];
+		return false;
+	}
+	getOrCreateModel(fileName) {
+		const uri = monaco_editor_core_exports.Uri.parse(fileName);
+		const model = monaco_editor_core_exports.editor.getModel(uri);
+		if (model) return model;
+		if (this.isLibFile(uri) && this._hasFetchedLibFiles) return monaco_editor_core_exports.editor.createModel(this._libFiles[uri.path.slice(1)], "typescript", uri);
+		const matchedLibFile = typescriptDefaults.getExtraLibs()[fileName];
+		if (matchedLibFile) return monaco_editor_core_exports.editor.createModel(matchedLibFile.content, "typescript", uri);
+		return null;
+	}
+	_containsLibFile(uris) {
+		for (let uri of uris) if (this.isLibFile(uri)) return true;
+		return false;
+	}
+	async fetchLibFilesIfNecessary(uris) {
+		if (!this._containsLibFile(uris)) return;
+		await this._fetchLibFiles();
+	}
+	_fetchLibFiles() {
+		if (!this._fetchLibFilesPromise) this._fetchLibFilesPromise = this._worker().then((w) => w.getLibFiles()).then((libFiles) => {
+			this._hasFetchedLibFiles = true;
+			this._libFiles = libFiles;
+		});
+		return this._fetchLibFilesPromise;
+	}
+};
+var DiagnosticsAdapter = class extends Adapter {
+	constructor(_libFiles, _defaults, _selector, worker) {
+		super(worker);
+		this._libFiles = _libFiles;
+		this._defaults = _defaults;
+		this._selector = _selector;
+		this._disposables = [];
+		this._listener = /* @__PURE__ */ Object.create(null);
+		const onModelAdd = (model) => {
+			if (model.getLanguageId() !== _selector) return;
+			const maybeValidate = () => {
+				const { onlyVisible } = this._defaults.getDiagnosticsOptions();
+				if (onlyVisible) {
+					if (model.isAttachedToEditor()) this._doValidate(model);
+				} else this._doValidate(model);
+			};
+			let handle;
+			const changeSubscription = model.onDidChangeContent(() => {
+				clearTimeout(handle);
+				handle = window.setTimeout(maybeValidate, 500);
+			});
+			const visibleSubscription = model.onDidChangeAttached(() => {
+				const { onlyVisible } = this._defaults.getDiagnosticsOptions();
+				if (onlyVisible) if (model.isAttachedToEditor()) maybeValidate();
+				else monaco_editor_core_exports.editor.setModelMarkers(model, this._selector, []);
+			});
+			this._listener[model.uri.toString()] = { dispose() {
+				changeSubscription.dispose();
+				visibleSubscription.dispose();
+				clearTimeout(handle);
+			} };
+			maybeValidate();
+		};
+		const onModelRemoved = (model) => {
+			monaco_editor_core_exports.editor.setModelMarkers(model, this._selector, []);
+			const key = model.uri.toString();
+			if (this._listener[key]) {
+				this._listener[key].dispose();
+				delete this._listener[key];
+			}
+		};
+		this._disposables.push(monaco_editor_core_exports.editor.onDidCreateModel((model) => onModelAdd(model)));
+		this._disposables.push(monaco_editor_core_exports.editor.onWillDisposeModel(onModelRemoved));
+		this._disposables.push(monaco_editor_core_exports.editor.onDidChangeModelLanguage((event) => {
+			onModelRemoved(event.model);
+			onModelAdd(event.model);
+		}));
+		this._disposables.push({ dispose() {
+			for (const model of monaco_editor_core_exports.editor.getModels()) onModelRemoved(model);
+		} });
+		const recomputeDiagostics = () => {
+			for (const model of monaco_editor_core_exports.editor.getModels()) {
+				onModelRemoved(model);
+				onModelAdd(model);
+			}
+		};
+		this._disposables.push(this._defaults.onDidChange(recomputeDiagostics));
+		this._disposables.push(this._defaults.onDidExtraLibsChange(recomputeDiagostics));
+		monaco_editor_core_exports.editor.getModels().forEach((model) => onModelAdd(model));
+	}
+	dispose() {
+		this._disposables.forEach((d) => d && d.dispose());
+		this._disposables = [];
+	}
+	async _doValidate(model) {
+		const worker = await this._worker(model.uri);
+		if (model.isDisposed()) return;
+		const promises = [];
+		const { noSyntaxValidation, noSemanticValidation, noSuggestionDiagnostics } = this._defaults.getDiagnosticsOptions();
+		if (!noSyntaxValidation) promises.push(worker.getSyntacticDiagnostics(model.uri.toString()));
+		if (!noSemanticValidation) promises.push(worker.getSemanticDiagnostics(model.uri.toString()));
+		if (!noSuggestionDiagnostics) promises.push(worker.getSuggestionDiagnostics(model.uri.toString()));
+		const allDiagnostics = await Promise.all(promises);
+		if (!allDiagnostics || model.isDisposed()) return;
+		const diagnostics = allDiagnostics.reduce((p, c) => c.concat(p), []).filter((d) => (this._defaults.getDiagnosticsOptions().diagnosticCodesToIgnore || []).indexOf(d.code) === -1);
+		const relatedUris = diagnostics.map((d) => d.relatedInformation || []).reduce((p, c) => c.concat(p), []).map((relatedInformation) => relatedInformation.file ? monaco_editor_core_exports.Uri.parse(relatedInformation.file.fileName) : null);
+		await this._libFiles.fetchLibFilesIfNecessary(relatedUris);
+		if (model.isDisposed()) return;
+		monaco_editor_core_exports.editor.setModelMarkers(model, this._selector, diagnostics.map((d) => this._convertDiagnostics(model, d)));
+	}
+	_convertDiagnostics(model, diag) {
+		const diagStart = diag.start || 0;
+		const diagLength = diag.length || 1;
+		const { lineNumber: startLineNumber, column: startColumn } = model.getPositionAt(diagStart);
+		const { lineNumber: endLineNumber, column: endColumn } = model.getPositionAt(diagStart + diagLength);
+		const tags = [];
+		if (diag.reportsUnnecessary) tags.push(monaco_editor_core_exports.MarkerTag.Unnecessary);
+		if (diag.reportsDeprecated) tags.push(monaco_editor_core_exports.MarkerTag.Deprecated);
+		return {
+			severity: this._tsDiagnosticCategoryToMarkerSeverity(diag.category),
+			startLineNumber,
+			startColumn,
+			endLineNumber,
+			endColumn,
+			message: flattenDiagnosticMessageText(diag.messageText, "\n"),
+			code: diag.code.toString(),
+			tags,
+			relatedInformation: this._convertRelatedInformation(model, diag.relatedInformation)
+		};
+	}
+	_convertRelatedInformation(model, relatedInformation) {
+		if (!relatedInformation) return [];
+		const result = [];
+		relatedInformation.forEach((info) => {
+			let relatedResource = model;
+			if (info.file) relatedResource = this._libFiles.getOrCreateModel(info.file.fileName);
+			if (!relatedResource) return;
+			const infoStart = info.start || 0;
+			const infoLength = info.length || 1;
+			const { lineNumber: startLineNumber, column: startColumn } = relatedResource.getPositionAt(infoStart);
+			const { lineNumber: endLineNumber, column: endColumn } = relatedResource.getPositionAt(infoStart + infoLength);
+			result.push({
+				resource: relatedResource.uri,
+				startLineNumber,
+				startColumn,
+				endLineNumber,
+				endColumn,
+				message: flattenDiagnosticMessageText(info.messageText, "\n")
+			});
+		});
+		return result;
+	}
+	_tsDiagnosticCategoryToMarkerSeverity(category) {
+		switch (category) {
+			case 1: return monaco_editor_core_exports.MarkerSeverity.Error;
+			case 3: return monaco_editor_core_exports.MarkerSeverity.Info;
+			case 0: return monaco_editor_core_exports.MarkerSeverity.Warning;
+			case 2: return monaco_editor_core_exports.MarkerSeverity.Hint;
+		}
+		return monaco_editor_core_exports.MarkerSeverity.Info;
+	}
+};
+var SuggestAdapter = class _SuggestAdapter extends Adapter {
+	get triggerCharacters() {
+		return ["."];
+	}
+	async provideCompletionItems(model, position, _context, token) {
+		const wordInfo = model.getWordUntilPosition(position);
+		const wordRange = new monaco_editor_core_exports.Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
+		const resource = model.uri;
+		const offset = model.getOffsetAt(position);
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const info = await worker.getCompletionsAtPosition(resource.toString(), offset);
+		if (!info || model.isDisposed()) return;
+		return { suggestions: info.entries.map((entry) => {
+			let range = wordRange;
+			if (entry.replacementSpan) {
+				const p1 = model.getPositionAt(entry.replacementSpan.start);
+				const p2 = model.getPositionAt(entry.replacementSpan.start + entry.replacementSpan.length);
+				range = new monaco_editor_core_exports.Range(p1.lineNumber, p1.column, p2.lineNumber, p2.column);
+			}
+			const tags = [];
+			if (entry.kindModifiers !== void 0 && entry.kindModifiers.indexOf("deprecated") !== -1) tags.push(monaco_editor_core_exports.languages.CompletionItemTag.Deprecated);
+			return {
+				uri: resource,
+				position,
+				offset,
+				range,
+				label: entry.name,
+				insertText: entry.name,
+				sortText: entry.sortText,
+				kind: _SuggestAdapter.convertKind(entry.kind),
+				tags
+			};
+		}) };
+	}
+	async resolveCompletionItem(item, token) {
+		const myItem = item;
+		const resource = myItem.uri;
+		const position = myItem.position;
+		const offset = myItem.offset;
+		const details = await (await this._worker(resource)).getCompletionEntryDetails(resource.toString(), offset, myItem.label);
+		if (!details) return myItem;
+		return {
+			uri: resource,
+			position,
+			label: details.name,
+			kind: _SuggestAdapter.convertKind(details.kind),
+			detail: displayPartsToString(details.displayParts),
+			documentation: { value: _SuggestAdapter.createDocumentationString(details) }
+		};
+	}
+	static convertKind(kind) {
+		switch (kind) {
+			case Kind.primitiveType:
+			case Kind.keyword: return monaco_editor_core_exports.languages.CompletionItemKind.Keyword;
+			case Kind.variable:
+			case Kind.localVariable: return monaco_editor_core_exports.languages.CompletionItemKind.Variable;
+			case Kind.memberVariable:
+			case Kind.memberGetAccessor:
+			case Kind.memberSetAccessor: return monaco_editor_core_exports.languages.CompletionItemKind.Field;
+			case Kind.function:
+			case Kind.memberFunction:
+			case Kind.constructSignature:
+			case Kind.callSignature:
+			case Kind.indexSignature: return monaco_editor_core_exports.languages.CompletionItemKind.Function;
+			case Kind.enum: return monaco_editor_core_exports.languages.CompletionItemKind.Enum;
+			case Kind.module: return monaco_editor_core_exports.languages.CompletionItemKind.Module;
+			case Kind.class: return monaco_editor_core_exports.languages.CompletionItemKind.Class;
+			case Kind.interface: return monaco_editor_core_exports.languages.CompletionItemKind.Interface;
+			case Kind.warning: return monaco_editor_core_exports.languages.CompletionItemKind.File;
+		}
+		return monaco_editor_core_exports.languages.CompletionItemKind.Property;
+	}
+	static createDocumentationString(details) {
+		let documentationString = displayPartsToString(details.documentation);
+		if (details.tags) for (const tag of details.tags) documentationString += `
+
+${tagToString(tag)}`;
+		return documentationString;
+	}
+};
+function tagToString(tag) {
+	let tagLabel = `*@${tag.name}*`;
+	if (tag.name === "param" && tag.text) {
+		const [paramName, ...rest] = tag.text;
+		tagLabel += `\`${paramName.text}\``;
+		if (rest.length > 0) tagLabel += ` \u2014 ${rest.map((r) => r.text).join(" ")}`;
+	} else if (Array.isArray(tag.text)) tagLabel += ` \u2014 ${tag.text.map((r) => r.text).join(" ")}`;
+	else if (tag.text) tagLabel += ` \u2014 ${tag.text}`;
+	return tagLabel;
+}
+var SignatureHelpAdapter = class _SignatureHelpAdapter extends Adapter {
+	constructor() {
+		super(...arguments);
+		this.signatureHelpTriggerCharacters = ["(", ","];
+	}
+	static _toSignatureHelpTriggerReason(context) {
+		switch (context.triggerKind) {
+			case monaco_editor_core_exports.languages.SignatureHelpTriggerKind.TriggerCharacter: if (context.triggerCharacter) if (context.isRetrigger) return {
+				kind: "retrigger",
+				triggerCharacter: context.triggerCharacter
+			};
+			else return {
+				kind: "characterTyped",
+				triggerCharacter: context.triggerCharacter
+			};
+			else return { kind: "invoked" };
+			case monaco_editor_core_exports.languages.SignatureHelpTriggerKind.ContentChange: return context.isRetrigger ? { kind: "retrigger" } : { kind: "invoked" };
+			case monaco_editor_core_exports.languages.SignatureHelpTriggerKind.Invoke:
+			default: return { kind: "invoked" };
+		}
+	}
+	async provideSignatureHelp(model, position, token, context) {
+		const resource = model.uri;
+		const offset = model.getOffsetAt(position);
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const info = await worker.getSignatureHelpItems(resource.toString(), offset, { triggerReason: _SignatureHelpAdapter._toSignatureHelpTriggerReason(context) });
+		if (!info || model.isDisposed()) return;
+		const ret = {
+			activeSignature: info.selectedItemIndex,
+			activeParameter: info.argumentIndex,
+			signatures: []
+		};
+		info.items.forEach((item) => {
+			const signature = {
+				label: "",
+				parameters: []
+			};
+			signature.documentation = { value: displayPartsToString(item.documentation) };
+			signature.label += displayPartsToString(item.prefixDisplayParts);
+			item.parameters.forEach((p, i, a) => {
+				const label = displayPartsToString(p.displayParts);
+				const parameter = {
+					label,
+					documentation: { value: displayPartsToString(p.documentation) }
+				};
+				signature.label += label;
+				signature.parameters.push(parameter);
+				if (i < a.length - 1) signature.label += displayPartsToString(item.separatorDisplayParts);
+			});
+			signature.label += displayPartsToString(item.suffixDisplayParts);
+			ret.signatures.push(signature);
+		});
+		return {
+			value: ret,
+			dispose() {}
+		};
+	}
+};
+var QuickInfoAdapter = class extends Adapter {
+	async provideHover(model, position, token) {
+		const resource = model.uri;
+		const offset = model.getOffsetAt(position);
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const info = await worker.getQuickInfoAtPosition(resource.toString(), offset);
+		if (!info || model.isDisposed()) return;
+		const documentation = displayPartsToString(info.documentation);
+		const tags = info.tags ? info.tags.map((tag) => tagToString(tag)).join("  \n\n") : "";
+		const contents = displayPartsToString(info.displayParts);
+		return {
+			range: this._textSpanToRange(model, info.textSpan),
+			contents: [{ value: "```typescript\n" + contents + "\n```\n" }, { value: documentation + (tags ? "\n\n" + tags : "") }]
+		};
+	}
+};
+var DocumentHighlightAdapter = class extends Adapter {
+	async provideDocumentHighlights(model, position, token) {
+		const resource = model.uri;
+		const offset = model.getOffsetAt(position);
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const entries = await worker.getDocumentHighlights(resource.toString(), offset, [resource.toString()]);
+		if (!entries || model.isDisposed()) return;
+		return entries.flatMap((entry) => {
+			return entry.highlightSpans.map((highlightSpans) => {
+				return {
+					range: this._textSpanToRange(model, highlightSpans.textSpan),
+					kind: highlightSpans.kind === "writtenReference" ? monaco_editor_core_exports.languages.DocumentHighlightKind.Write : monaco_editor_core_exports.languages.DocumentHighlightKind.Text
+				};
+			});
+		});
+	}
+};
+var DefinitionAdapter = class extends Adapter {
+	constructor(_libFiles, worker) {
+		super(worker);
+		this._libFiles = _libFiles;
+	}
+	async provideDefinition(model, position, token) {
+		const resource = model.uri;
+		const offset = model.getOffsetAt(position);
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const entries = await worker.getDefinitionAtPosition(resource.toString(), offset);
+		if (!entries || model.isDisposed()) return;
+		await this._libFiles.fetchLibFilesIfNecessary(entries.map((entry) => monaco_editor_core_exports.Uri.parse(entry.fileName)));
+		if (model.isDisposed()) return;
+		const result = [];
+		for (let entry of entries) {
+			const refModel = this._libFiles.getOrCreateModel(entry.fileName);
+			if (refModel) result.push({
+				uri: refModel.uri,
+				range: this._textSpanToRange(refModel, entry.textSpan)
+			});
+		}
+		return result;
+	}
+};
+var ReferenceAdapter = class extends Adapter {
+	constructor(_libFiles, worker) {
+		super(worker);
+		this._libFiles = _libFiles;
+	}
+	async provideReferences(model, position, context, token) {
+		const resource = model.uri;
+		const offset = model.getOffsetAt(position);
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const entries = await worker.getReferencesAtPosition(resource.toString(), offset);
+		if (!entries || model.isDisposed()) return;
+		await this._libFiles.fetchLibFilesIfNecessary(entries.map((entry) => monaco_editor_core_exports.Uri.parse(entry.fileName)));
+		if (model.isDisposed()) return;
+		const result = [];
+		for (let entry of entries) {
+			const refModel = this._libFiles.getOrCreateModel(entry.fileName);
+			if (refModel) result.push({
+				uri: refModel.uri,
+				range: this._textSpanToRange(refModel, entry.textSpan)
+			});
+		}
+		return result;
+	}
+};
+var OutlineAdapter = class extends Adapter {
+	async provideDocumentSymbols(model, token) {
+		const resource = model.uri;
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const root = await worker.getNavigationTree(resource.toString());
+		if (!root || model.isDisposed()) return;
+		const convert = (item, containerLabel) => {
+			return {
+				name: item.text,
+				detail: "",
+				kind: outlineTypeTable[item.kind] || monaco_editor_core_exports.languages.SymbolKind.Variable,
+				range: this._textSpanToRange(model, item.spans[0]),
+				selectionRange: this._textSpanToRange(model, item.spans[0]),
+				tags: [],
+				children: item.childItems?.map((child) => convert(child, item.text)),
+				containerName: containerLabel
+			};
+		};
+		return root.childItems ? root.childItems.map((item) => convert(item)) : [];
+	}
+};
+var Kind = class {
+	static {
+		this.unknown = "";
+	}
+	static {
+		this.keyword = "keyword";
+	}
+	static {
+		this.script = "script";
+	}
+	static {
+		this.module = "module";
+	}
+	static {
+		this.class = "class";
+	}
+	static {
+		this.interface = "interface";
+	}
+	static {
+		this.type = "type";
+	}
+	static {
+		this.enum = "enum";
+	}
+	static {
+		this.variable = "var";
+	}
+	static {
+		this.localVariable = "local var";
+	}
+	static {
+		this.function = "function";
+	}
+	static {
+		this.localFunction = "local function";
+	}
+	static {
+		this.memberFunction = "method";
+	}
+	static {
+		this.memberGetAccessor = "getter";
+	}
+	static {
+		this.memberSetAccessor = "setter";
+	}
+	static {
+		this.memberVariable = "property";
+	}
+	static {
+		this.constructorImplementation = "constructor";
+	}
+	static {
+		this.callSignature = "call";
+	}
+	static {
+		this.indexSignature = "index";
+	}
+	static {
+		this.constructSignature = "construct";
+	}
+	static {
+		this.parameter = "parameter";
+	}
+	static {
+		this.typeParameter = "type parameter";
+	}
+	static {
+		this.primitiveType = "primitive type";
+	}
+	static {
+		this.label = "label";
+	}
+	static {
+		this.alias = "alias";
+	}
+	static {
+		this.const = "const";
+	}
+	static {
+		this.let = "let";
+	}
+	static {
+		this.warning = "warning";
+	}
+};
+var outlineTypeTable = /* @__PURE__ */ Object.create(null);
+outlineTypeTable[Kind.module] = monaco_editor_core_exports.languages.SymbolKind.Module;
+outlineTypeTable[Kind.class] = monaco_editor_core_exports.languages.SymbolKind.Class;
+outlineTypeTable[Kind.enum] = monaco_editor_core_exports.languages.SymbolKind.Enum;
+outlineTypeTable[Kind.interface] = monaco_editor_core_exports.languages.SymbolKind.Interface;
+outlineTypeTable[Kind.memberFunction] = monaco_editor_core_exports.languages.SymbolKind.Method;
+outlineTypeTable[Kind.memberVariable] = monaco_editor_core_exports.languages.SymbolKind.Property;
+outlineTypeTable[Kind.memberGetAccessor] = monaco_editor_core_exports.languages.SymbolKind.Property;
+outlineTypeTable[Kind.memberSetAccessor] = monaco_editor_core_exports.languages.SymbolKind.Property;
+outlineTypeTable[Kind.variable] = monaco_editor_core_exports.languages.SymbolKind.Variable;
+outlineTypeTable[Kind.const] = monaco_editor_core_exports.languages.SymbolKind.Variable;
+outlineTypeTable[Kind.localVariable] = monaco_editor_core_exports.languages.SymbolKind.Variable;
+outlineTypeTable[Kind.variable] = monaco_editor_core_exports.languages.SymbolKind.Variable;
+outlineTypeTable[Kind.function] = monaco_editor_core_exports.languages.SymbolKind.Function;
+outlineTypeTable[Kind.localFunction] = monaco_editor_core_exports.languages.SymbolKind.Function;
+var FormatHelper = class extends Adapter {
+	static _convertOptions(options) {
+		return {
+			ConvertTabsToSpaces: options.insertSpaces,
+			TabSize: options.tabSize,
+			IndentSize: options.tabSize,
+			IndentStyle: 2,
+			NewLineCharacter: "\n",
+			InsertSpaceAfterCommaDelimiter: true,
+			InsertSpaceAfterSemicolonInForStatements: true,
+			InsertSpaceBeforeAndAfterBinaryOperators: true,
+			InsertSpaceAfterKeywordsInControlFlowStatements: true,
+			InsertSpaceAfterFunctionKeywordForAnonymousFunctions: true,
+			InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
+			InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
+			InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
+			PlaceOpenBraceOnNewLineForControlBlocks: false,
+			PlaceOpenBraceOnNewLineForFunctions: false
+		};
+	}
+	_convertTextChanges(model, change) {
+		return {
+			text: change.newText,
+			range: this._textSpanToRange(model, change.span)
+		};
+	}
+};
+var FormatAdapter = class extends FormatHelper {
+	constructor() {
+		super(...arguments);
+		this.canFormatMultipleRanges = false;
+	}
+	async provideDocumentRangeFormattingEdits(model, range, options, token) {
+		const resource = model.uri;
+		const startOffset = model.getOffsetAt({
+			lineNumber: range.startLineNumber,
+			column: range.startColumn
+		});
+		const endOffset = model.getOffsetAt({
+			lineNumber: range.endLineNumber,
+			column: range.endColumn
+		});
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const edits = await worker.getFormattingEditsForRange(resource.toString(), startOffset, endOffset, FormatHelper._convertOptions(options));
+		if (!edits || model.isDisposed()) return;
+		return edits.map((edit) => this._convertTextChanges(model, edit));
+	}
+};
+var FormatOnTypeAdapter = class extends FormatHelper {
+	get autoFormatTriggerCharacters() {
+		return [
+			";",
+			"}",
+			"\n"
+		];
+	}
+	async provideOnTypeFormattingEdits(model, position, ch, options, token) {
+		const resource = model.uri;
+		const offset = model.getOffsetAt(position);
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const edits = await worker.getFormattingEditsAfterKeystroke(resource.toString(), offset, ch, FormatHelper._convertOptions(options));
+		if (!edits || model.isDisposed()) return;
+		return edits.map((edit) => this._convertTextChanges(model, edit));
+	}
+};
+var CodeActionAdaptor = class extends FormatHelper {
+	async provideCodeActions(model, range, context, token) {
+		const resource = model.uri;
+		const start = model.getOffsetAt({
+			lineNumber: range.startLineNumber,
+			column: range.startColumn
+		});
+		const end = model.getOffsetAt({
+			lineNumber: range.endLineNumber,
+			column: range.endColumn
+		});
+		const formatOptions = FormatHelper._convertOptions(model.getOptions());
+		const errorCodes = context.markers.filter((m) => m.code).map((m) => m.code).map(Number);
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const codeFixes = await worker.getCodeFixesAtPosition(resource.toString(), start, end, errorCodes, formatOptions);
+		if (!codeFixes || model.isDisposed()) return {
+			actions: [],
+			dispose: () => {}
+		};
+		return {
+			actions: codeFixes.filter((fix) => {
+				return fix.changes.filter((change) => change.isNewFile).length === 0;
+			}).map((fix) => {
+				return this._tsCodeFixActionToMonacoCodeAction(model, context, fix);
+			}),
+			dispose: () => {}
+		};
+	}
+	_tsCodeFixActionToMonacoCodeAction(model, context, codeFix) {
+		const edits = [];
+		for (const change of codeFix.changes) for (const textChange of change.textChanges) edits.push({
+			resource: model.uri,
+			versionId: void 0,
+			textEdit: {
+				range: this._textSpanToRange(model, textChange.span),
+				text: textChange.newText
+			}
+		});
+		return {
+			title: codeFix.description,
+			edit: { edits },
+			diagnostics: context.markers,
+			kind: "quickfix"
+		};
+	}
+};
+var RenameAdapter = class extends Adapter {
+	constructor(_libFiles, worker) {
+		super(worker);
+		this._libFiles = _libFiles;
+	}
+	async provideRenameEdits(model, position, newName, token) {
+		const resource = model.uri;
+		const fileName = resource.toString();
+		const offset = model.getOffsetAt(position);
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return;
+		const renameInfo = await worker.getRenameInfo(fileName, offset, { allowRenameOfImportPath: false });
+		if (renameInfo.canRename === false) return {
+			edits: [],
+			rejectReason: renameInfo.localizedErrorMessage
+		};
+		if (renameInfo.fileToRename !== void 0) throw new Error("Renaming files is not supported.");
+		const renameLocations = await worker.findRenameLocations(fileName, offset, false, false, false);
+		if (!renameLocations || model.isDisposed()) return;
+		const edits = [];
+		for (const renameLocation of renameLocations) {
+			const model2 = this._libFiles.getOrCreateModel(renameLocation.fileName);
+			if (model2) edits.push({
+				resource: model2.uri,
+				versionId: void 0,
+				textEdit: {
+					range: this._textSpanToRange(model2, renameLocation.textSpan),
+					text: newName
+				}
+			});
+			else throw new Error(`Unknown file ${renameLocation.fileName}.`);
+		}
+		return { edits };
+	}
+};
+var InlayHintsAdapter = class extends Adapter {
+	async provideInlayHints(model, range, token) {
+		const resource = model.uri;
+		const fileName = resource.toString();
+		const start = model.getOffsetAt({
+			lineNumber: range.startLineNumber,
+			column: range.startColumn
+		});
+		const end = model.getOffsetAt({
+			lineNumber: range.endLineNumber,
+			column: range.endColumn
+		});
+		const worker = await this._worker(resource);
+		if (model.isDisposed()) return null;
+		return {
+			hints: (await worker.provideInlayHints(fileName, start, end)).map((hint) => {
+				return {
+					...hint,
+					label: hint.text,
+					position: model.getPositionAt(hint.position),
+					kind: this._convertHintKind(hint.kind)
+				};
+			}),
+			dispose: () => {}
+		};
+	}
+	_convertHintKind(kind) {
+		switch (kind) {
+			case "Parameter": return monaco_editor_core_exports.languages.InlayHintKind.Parameter;
+			case "Type": return monaco_editor_core_exports.languages.InlayHintKind.Type;
+			default: return monaco_editor_core_exports.languages.InlayHintKind.Type;
+		}
+	}
+};
+var javaScriptWorker;
+var typeScriptWorker;
+function setupTypeScript(defaults) {
+	typeScriptWorker = setupMode(defaults, "typescript");
+}
+function setupJavaScript(defaults) {
+	javaScriptWorker = setupMode(defaults, "javascript");
+}
+function getJavaScriptWorker() {
+	return new Promise((resolve, reject) => {
+		if (!javaScriptWorker) return reject("JavaScript not registered!");
+		resolve(javaScriptWorker);
+	});
+}
+function getTypeScriptWorker() {
+	return new Promise((resolve, reject) => {
+		if (!typeScriptWorker) return reject("TypeScript not registered!");
+		resolve(typeScriptWorker);
+	});
+}
+function setupMode(defaults, modeId) {
+	const disposables = [];
+	const providers = [];
+	const client = new WorkerManager(modeId, defaults);
+	disposables.push(client);
+	const worker = (...uris) => {
+		return client.getLanguageServiceWorker(...uris);
+	};
+	const libFiles = new LibFiles(worker);
+	function registerProviders() {
+		const { modeConfiguration } = defaults;
+		disposeAll(providers);
+		if (modeConfiguration.completionItems) providers.push(monaco_editor_core_exports.languages.registerCompletionItemProvider(modeId, new SuggestAdapter(worker)));
+		if (modeConfiguration.signatureHelp) providers.push(monaco_editor_core_exports.languages.registerSignatureHelpProvider(modeId, new SignatureHelpAdapter(worker)));
+		if (modeConfiguration.hovers) providers.push(monaco_editor_core_exports.languages.registerHoverProvider(modeId, new QuickInfoAdapter(worker)));
+		if (modeConfiguration.documentHighlights) providers.push(monaco_editor_core_exports.languages.registerDocumentHighlightProvider(modeId, new DocumentHighlightAdapter(worker)));
+		if (modeConfiguration.definitions) providers.push(monaco_editor_core_exports.languages.registerDefinitionProvider(modeId, new DefinitionAdapter(libFiles, worker)));
+		if (modeConfiguration.references) providers.push(monaco_editor_core_exports.languages.registerReferenceProvider(modeId, new ReferenceAdapter(libFiles, worker)));
+		if (modeConfiguration.documentSymbols) providers.push(monaco_editor_core_exports.languages.registerDocumentSymbolProvider(modeId, new OutlineAdapter(worker)));
+		if (modeConfiguration.rename) providers.push(monaco_editor_core_exports.languages.registerRenameProvider(modeId, new RenameAdapter(libFiles, worker)));
+		if (modeConfiguration.documentRangeFormattingEdits) providers.push(monaco_editor_core_exports.languages.registerDocumentRangeFormattingEditProvider(modeId, new FormatAdapter(worker)));
+		if (modeConfiguration.onTypeFormattingEdits) providers.push(monaco_editor_core_exports.languages.registerOnTypeFormattingEditProvider(modeId, new FormatOnTypeAdapter(worker)));
+		if (modeConfiguration.codeActions) providers.push(monaco_editor_core_exports.languages.registerCodeActionProvider(modeId, new CodeActionAdaptor(worker)));
+		if (modeConfiguration.inlayHints) providers.push(monaco_editor_core_exports.languages.registerInlayHintsProvider(modeId, new InlayHintsAdapter(worker)));
+		if (modeConfiguration.diagnostics) providers.push(new DiagnosticsAdapter(libFiles, defaults, modeId, worker));
+	}
+	registerProviders();
+	disposables.push(asDisposable(providers));
+	return worker;
+}
+function asDisposable(disposables) {
+	return { dispose: () => disposeAll(disposables) };
+}
+function disposeAll(disposables) {
+	while (disposables.length) disposables.pop().dispose();
+}
+//#endregion
+export { Adapter, CodeActionAdaptor, DefinitionAdapter, DiagnosticsAdapter, DocumentHighlightAdapter, FormatAdapter, FormatHelper, FormatOnTypeAdapter, InlayHintsAdapter, Kind, LibFiles, OutlineAdapter, QuickInfoAdapter, ReferenceAdapter, RenameAdapter, SignatureHelpAdapter, SuggestAdapter, WorkerManager, flattenDiagnosticMessageText, getJavaScriptWorker, getTypeScriptWorker, setupJavaScript, setupTypeScript };