@typespec/playground 0.14.0-dev.2 → 0.14.0-dev.4

package/dist/services-CELCHECS.js

@@ -0,0 +1,723 @@
+import { TypeSpecLanguageConfiguration, createSourceFile, getSourceFileKindFromExt, resolvePath } from "@typespec/compiler";
+import * as monaco from "monaco-editor";
+import * as lsp from "vscode-languageserver";
+import { DiagnosticSeverity, DocumentHighlightKind, FormattingOptions, Range } from "vscode-languageserver";
+import { TextDocument } from "vscode-languageserver-textdocument";
+//#region src/react/debug.ts
+/**
+* Prints debug information to the console.
+*/
+function printDebugInfo() {
+	console.info("TypeSpec Playground");
+	console.info("Some variables are bound to the `window` object in the browser console for debugging.");
+	console.info(" - `program`: The current TypeSpec program.");
+	console.info(" - `host`: The current compiler host.");
+	console.info(" - `compiler`: The TypeSpec compiler API.");
+	console.info(" - `$$`: A Typekit instance bound to the current program.");
+	console.info(" - `libs`: A map of all loaded TypeSpec libraries.");
+	console.info(" - `vars`: Types bookmarked in the type graph.");
+}
+/**
+* Get the global debug variables bound to the `window` object.
+*/
+function debugGlobals() {
+	return window;
+}
+/**
+* Gets the global debug libraries
+*/
+function debugLibs() {
+	return window.libs ??= {};
+}
+//#endregion
+//#region src/core.ts
+async function importTypeSpecCompiler(config) {
+	const compiler = await importLibrary("@typespec/compiler", config);
+	debugGlobals().compiler = compiler;
+	return compiler;
+}
+/**
+* @param name Import name.
+* @returns Promise with the loaded module.
+*/
+async function importLibrary(name, config) {
+	const lib = await (config.useShim ? importShim(name) : import(
+		/* @vite-ignore */
+		/* webpackIgnore: true */
+		name
+));
+	debugLibs()[name] = lib;
+	return lib;
+}
+/**
+* Loading external import map doesn't work yet
+*
+* https://github.com/WICG/import-maps/issues/235
+*
+* A polyfill for importmap is loaded but required calling importShim instead of the native import https://github.com/guybedford/es-module-shims
+* @param name Import name.
+* @returns Promise with the loaded module.
+*/
+async function importShim(name) {
+	return window.importShim(name);
+}
+//#endregion
+//#region src/browser-host.ts
+function resolveVirtualPath(path, ...paths) {
+	return resolvePath("/test", path, ...paths);
+}
+/**
+* @internal
+*/
+function createBrowserHostInternal(options) {
+	const virtualFs = /* @__PURE__ */ new Map();
+	const jsImports = /* @__PURE__ */ new Map();
+	const libraries = { ...options.libraries };
+	function registerLibraryFiles(libName, lib) {
+		for (const [key, value] of Object.entries(lib._TypeSpecLibrary_.typespecSourceFiles)) virtualFs.set(`/test/node_modules/${libName}/${key}`, value);
+		for (const [key, value] of Object.entries(lib._TypeSpecLibrary_.jsSourceFiles)) addJsImport(`/test/node_modules/${libName}/${key}`, value);
+	}
+	function updatePackageJson() {
+		virtualFs.set(`/test/package.json`, JSON.stringify({
+			name: "playground-pkg",
+			dependencies: Object.fromEntries(Object.values(libraries).map((x) => [x.name, x.packageJson.version]))
+		}));
+	}
+	for (const [libName, lib] of Object.entries(libraries)) registerLibraryFiles(libName, lib);
+	updatePackageJson();
+	function addJsImport(path, value) {
+		virtualFs.set(path, "");
+		jsImports.set(path, value);
+	}
+	return {
+		compiler: options.compiler,
+		libraries,
+		async readUrl(url) {
+			const contents = virtualFs.get(url);
+			if (contents === void 0) {
+				const e = /* @__PURE__ */ new Error(`File ${url} not found.`);
+				e.code = "ENOENT";
+				throw e;
+			}
+			return createSourceFile(contents, url);
+		},
+		async readFile(path) {
+			path = resolveVirtualPath(path);
+			const contents = virtualFs.get(path);
+			if (contents === void 0) {
+				const e = /* @__PURE__ */ new Error(`File ${path} not found.`);
+				e.code = "ENOENT";
+				throw e;
+			}
+			return createSourceFile(contents, path);
+		},
+		async writeFile(path, content) {
+			path = resolveVirtualPath(path);
+			virtualFs.set(path, content);
+		},
+		async readDir(path) {
+			path = resolveVirtualPath(path);
+			const fileFolder = [...virtualFs.keys()].filter((x) => x.startsWith(`${path}/`)).map((x) => x.replace(`${path}/`, "")).map((x) => {
+				const index = x.indexOf("/");
+				return index !== -1 ? x.substring(0, index) : x;
+			});
+			return [...new Set(fileFolder)];
+		},
+		async rm(path) {
+			path = resolveVirtualPath(path);
+			for (const key of virtualFs.keys()) if (key === path || key.startsWith(`${path}/`)) virtualFs.delete(key);
+		},
+		getLibDirs() {
+			if (virtualFs.has(resolveVirtualPath("/test/node_modules/@typespec/compiler/lib/std/main.tsp"))) return [resolveVirtualPath("/test/node_modules/@typespec/compiler/lib/std")];
+			else return [resolveVirtualPath("/test/node_modules/@typespec/compiler/lib")];
+		},
+		getExecutionRoot() {
+			return resolveVirtualPath("/test/node_modules/@typespec/compiler");
+		},
+		async getJsImport(path) {
+			path = resolveVirtualPath(path);
+			const module = await jsImports.get(path);
+			if (module === void 0) {
+				const e = /* @__PURE__ */ new Error(`Module ${path} not found`);
+				e.code = "MODULE_NOT_FOUND";
+				throw e;
+			}
+			return module;
+		},
+		async stat(path) {
+			path = resolveVirtualPath(path);
+			if (virtualFs.has(path)) return {
+				isDirectory() {
+					return false;
+				},
+				isFile() {
+					return true;
+				}
+			};
+			for (const fsPath of virtualFs.keys()) if (fsPath.startsWith(path) && fsPath !== path) return {
+				isDirectory() {
+					return true;
+				},
+				isFile() {
+					return false;
+				}
+			};
+			const e = /* @__PURE__ */ new Error(`File ${path} not found.`);
+			e.code = "ENOENT";
+			throw e;
+		},
+		async realpath(path) {
+			return path;
+		},
+		getSourceFileKind: getSourceFileKindFromExt,
+		logSink: console,
+		mkdirp: async (path) => path,
+		fileURLToPath(path) {
+			return path.replace("inmemory:/", "");
+		},
+		pathToFileURL(path) {
+			return "inmemory:/" + resolveVirtualPath(path);
+		}
+	};
+}
+/**
+* Load libraries in parallel from the given list.
+* @param libsToLoad List of library names. Must be available in the webpage importmap.
+* @param importOptions Import configuration.
+*/
+async function loadLibraries(libsToLoad, importOptions = {}) {
+	const entries = await Promise.all(libsToLoad.map(async (libName) => {
+		const { _TypeSpecLibrary_, $lib, $linter } = await importLibrary(libName, importOptions);
+		return [libName, {
+			name: libName,
+			isEmitter: $lib?.emitter,
+			definition: $lib,
+			packageJson: JSON.parse(_TypeSpecLibrary_.typespecSourceFiles["package.json"]),
+			linter: $linter,
+			_TypeSpecLibrary_
+		}];
+	}));
+	return Object.fromEntries(entries);
+}
+/**
+* Create the browser host from the list of libraries.
+* @param libsToLoad List of libraries to load. Those must be set in the webpage importmap.
+* @param importOptions Import configuration.
+* @returns
+*/
+async function createBrowserHost(libsToLoad, importOptions = {}) {
+	const [libraries, compiler] = await Promise.all([loadLibraries(libsToLoad, importOptions), importTypeSpecCompiler(importOptions)]);
+	return createBrowserHostInternal({
+		compiler,
+		libraries
+	});
+}
+//#endregion
+//#region src/lsp/lsp-to-monaco.ts
+function range$1(range) {
+	return {
+		startColumn: range.start.character + 1,
+		startLineNumber: range.start.line + 1,
+		endColumn: range.end.character + 1,
+		endLineNumber: range.end.line + 1
+	};
+}
+function foldingRange(range) {
+	return {
+		start: range.startLine + 1,
+		end: range.endLine + 1,
+		kind: range.kind ? new monaco.languages.FoldingRangeKind(range.kind) : void 0
+	};
+}
+function textEdits(edit) {
+	return edit.map(textEdit);
+}
+function textEdit(edit) {
+	return {
+		range: range$1(edit.range),
+		text: edit.newText
+	};
+}
+function signatureHelp(help) {
+	return {
+		signatures: help?.signatures.map((x) => ({
+			...x,
+			parameters: x.parameters ?? []
+		})) ?? [],
+		activeSignature: help?.activeSignature ?? 0,
+		activeParameter: help?.activeParameter ?? 0
+	};
+}
+function command(command) {
+	return {
+		id: command.command,
+		title: command.title,
+		arguments: command.arguments
+	};
+}
+function severity$1(severity) {
+	switch (severity) {
+		case DiagnosticSeverity.Error: return monaco.MarkerSeverity.Error;
+		case DiagnosticSeverity.Warning: return monaco.MarkerSeverity.Warning;
+		case DiagnosticSeverity.Hint: return monaco.MarkerSeverity.Hint;
+		case DiagnosticSeverity.Information: return monaco.MarkerSeverity.Info;
+	}
+}
+function diagnostic(diagnostic) {
+	return {
+		severity: diagnostic.severity ? severity$1(diagnostic.severity) : monaco.MarkerSeverity.Error,
+		message: diagnostic.message,
+		code: diagnostic.code?.toString(),
+		source: diagnostic.source,
+		startLineNumber: diagnostic.range.start.line + 1,
+		startColumn: diagnostic.range.start.character + 1,
+		endLineNumber: diagnostic.range.end.line + 1,
+		endColumn: diagnostic.range.end.character + 1
+	};
+}
+function codeAction(action) {
+	return {
+		title: action.title,
+		kind: action.kind,
+		diagnostics: action.diagnostics?.map(diagnostic),
+		command: action.command && command(action.command)
+	};
+}
+var LspToMonaco = {
+	range: range$1,
+	foldingRange,
+	textEdits,
+	textEdit,
+	signatureHelp,
+	codeAction,
+	command
+};
+//#endregion
+//#region src/lsp/monaco-to-lsp.ts
+function textDocumentForModel(model) {
+	return TextDocument.create(model.uri.toString(), "typespec", model.getVersionId(), model.getValue());
+}
+function position(pos) {
+	return {
+		line: pos.lineNumber - 1,
+		character: pos.column - 1
+	};
+}
+function range(range) {
+	return Range.create({
+		line: range.startLineNumber - 1,
+		character: range.startColumn - 1
+	}, {
+		line: range.endLineNumber - 1,
+		character: range.endColumn - 1
+	});
+}
+function severity(severity) {
+	switch (severity) {
+		case monaco.MarkerSeverity.Error: return DiagnosticSeverity.Error;
+		case monaco.MarkerSeverity.Warning: return DiagnosticSeverity.Warning;
+		case monaco.MarkerSeverity.Hint: return DiagnosticSeverity.Hint;
+		case monaco.MarkerSeverity.Info: return DiagnosticSeverity.Information;
+	}
+}
+function markerToDiagnostic(marker) {
+	return {
+		severity: marker.severity ? severity(marker.severity) : DiagnosticSeverity.Error,
+		range: range(marker),
+		message: marker.message,
+		code: typeof marker.code === "string" ? marker.code : marker.code?.value,
+		source: marker.source,
+		data: marker.relatedInformation
+	};
+}
+function codeActionContext(context) {
+	return {
+		only: context.only ? [context.only] : void 0,
+		triggerKind: context.trigger,
+		diagnostics: context.markers.map(markerToDiagnostic)
+	};
+}
+var MonacoToLsp = {
+	textDocumentForModel,
+	position,
+	range,
+	codeActionContext
+};
+//#endregion
+//#region src/services.ts
+var _currentDiagnostics = [];
+var _currentCompiler;
+/**
+* Update the current diagnostics so the Monaco code action provider can
+* surface codefixes for the playground's own compilation results.
+* Call this after every compilation.
+*/
+function updateDiagnosticsForCodeFixes(compiler, diagnostics) {
+	_currentDiagnostics = diagnostics;
+	_currentCompiler = compiler;
+}
+function getIndentAction(value) {
+	switch (value) {
+		case "none": return monaco.languages.IndentAction.None;
+		case "indent": return monaco.languages.IndentAction.Indent;
+		case "indentOutdent": return monaco.languages.IndentAction.IndentOutdent;
+		case "outdent": return monaco.languages.IndentAction.Outdent;
+	}
+}
+function getTypeSpecLanguageConfiguration() {
+	return {
+		...TypeSpecLanguageConfiguration,
+		onEnterRules: TypeSpecLanguageConfiguration.onEnterRules.map((rule) => {
+			return {
+				beforeText: new RegExp(rule.beforeText.pattern),
+				previousLineText: "previousLineText" in rule ? new RegExp(rule.previousLineText.pattern) : void 0,
+				action: {
+					indentAction: getIndentAction(rule.action.indent),
+					appendText: "appendText" in rule.action ? rule.action.appendText : void 0,
+					removeText: "removeText" in rule.action ? rule.action.removeText : void 0
+				}
+			};
+		})
+	};
+}
+async function registerMonacoLanguage(host) {
+	monaco.languages.register({
+		id: "typespec",
+		extensions: [".tsp"]
+	});
+	monaco.languages.setLanguageConfiguration("typespec", getTypeSpecLanguageConfiguration());
+	if (window.registeredServices) return;
+	window.registeredServices = true;
+	const serverHost = {
+		compilerHost: host,
+		getOpenDocumentByURL(url) {
+			const model = monaco.editor.getModel(monaco.Uri.parse(url));
+			return model ? MonacoToLsp.textDocumentForModel(model) : void 0;
+		},
+		sendDiagnostics() {},
+		log: (log) => {
+			switch (log.level) {
+				case "error":
+					console.error(log);
+					break;
+				case "warning":
+					console.warn(log);
+					break;
+				case "info":
+					console.info(log);
+					break;
+				case "debug":
+					console.debug(log);
+					break;
+				default: break;
+			}
+		},
+		applyEdit(param) {
+			return Promise.resolve({ applied: false });
+		}
+	};
+	const { createServer } = host.compiler;
+	const serverLib = createServer(serverHost);
+	const lsConfig = await serverLib.initialize({
+		capabilities: {},
+		processId: 1,
+		workspaceFolders: [],
+		rootUri: "inmemory://"
+	});
+	serverLib.initialized({});
+	monaco.editor.onDidCreateModel((model) => {
+		if (model.getLanguageId() !== "typespec") return;
+		model.onDidChangeContent(async (changes) => {
+			serverLib.checkChange(monacoToLspChangeEvent(model));
+		});
+	});
+	function monacoToLspChangeEvent(model) {
+		return { document: MonacoToLsp.textDocumentForModel(model) };
+	}
+	function lspDocumentArgs(model) {
+		return { textDocument: MonacoToLsp.textDocumentForModel(model) };
+	}
+	function lspArgs(model, pos) {
+		return {
+			...lspDocumentArgs(model),
+			position: lspPosition(pos)
+		};
+	}
+	function lspPosition(pos) {
+		return {
+			line: pos.lineNumber - 1,
+			character: pos.column - 1
+		};
+	}
+	function lspFormattingOptions(options) {
+		return FormattingOptions.create(options.tabSize, options.insertSpaces);
+	}
+	function monacoLocation(loc) {
+		return {
+			uri: monaco.Uri.parse(loc.uri),
+			range: LspToMonaco.range(loc.range)
+		};
+	}
+	function monacoDocumentHighlight(highlight) {
+		return {
+			range: LspToMonaco.range(highlight.range),
+			kind: monacoDocumentHighlightKind(highlight.kind)
+		};
+	}
+	function monacoDocumentHighlightKind(kind) {
+		switch (kind) {
+			case DocumentHighlightKind.Text: return monaco.languages.DocumentHighlightKind.Text;
+			case DocumentHighlightKind.Read: return monaco.languages.DocumentHighlightKind.Read;
+			case DocumentHighlightKind.Write: return monaco.languages.DocumentHighlightKind.Write;
+			default: return;
+		}
+	}
+	function monacoHoverContents(contents) {
+		return [{ value: contents.value }];
+	}
+	function monacoHover(hover) {
+		if (Array.isArray(hover.contents) || lsp.MarkedString.is(hover.contents)) throw new Error("MarkedString (deprecated) not supported.");
+		return {
+			contents: monacoHoverContents(hover.contents),
+			range: hover.range ? LspToMonaco.range(hover.range) : void 0
+		};
+	}
+	function monacoWorkspaceEdit(edit) {
+		const edits = [];
+		for (const [uri, changes] of Object.entries(edit.changes ?? {})) {
+			const resource = monaco.Uri.parse(uri);
+			for (const change of changes) edits.push({
+				resource,
+				textEdit: LspToMonaco.textEdit(change),
+				versionId: void 0
+			});
+		}
+		return { edits };
+	}
+	monaco.languages.registerDefinitionProvider("typespec", { async provideDefinition(model, position) {
+		return (await serverLib.gotoDefinition(lspArgs(model, position))).map(monacoLocation);
+	} });
+	monaco.languages.registerReferenceProvider("typespec", { async provideReferences(model, position, context) {
+		return (await serverLib.findReferences({
+			...lspArgs(model, position),
+			context
+		})).map(monacoLocation);
+	} });
+	monaco.languages.registerRenameProvider("typespec", {
+		async resolveRenameLocation(model, position) {
+			const result = await serverLib.prepareRename(lspArgs(model, position));
+			if (!result) throw new Error("This element can't be renamed.");
+			const text = model.getWordAtPosition(position)?.word;
+			if (!text) throw new Error("Failed to obtain word at position.");
+			return {
+				text,
+				range: LspToMonaco.range(result)
+			};
+		},
+		async provideRenameEdits(model, position, newName) {
+			return monacoWorkspaceEdit(await serverLib.rename({
+				...lspArgs(model, position),
+				newName
+			}));
+		}
+	});
+	monaco.languages.registerFoldingRangeProvider("typespec", { async provideFoldingRanges(model) {
+		return (await serverLib.getFoldingRanges(lspDocumentArgs(model))).map(LspToMonaco.foldingRange);
+	} });
+	monaco.languages.registerHoverProvider("typespec", { async provideHover(model, position) {
+		return monacoHover(await serverLib.getHover(lspArgs(model, position)));
+	} });
+	monaco.languages.registerSignatureHelpProvider("typespec", {
+		signatureHelpTriggerCharacters: [
+			"(",
+			",",
+			"<"
+		],
+		signatureHelpRetriggerCharacters: [")"],
+		async provideSignatureHelp(model, position) {
+			const help = await serverLib.getSignatureHelp(lspArgs(model, position));
+			return {
+				value: LspToMonaco.signatureHelp(help),
+				dispose: () => {}
+			};
+		}
+	});
+	monaco.languages.registerDocumentFormattingEditProvider("typespec", { async provideDocumentFormattingEdits(model, options, token) {
+		const edits = await serverLib.formatDocument({
+			...lspDocumentArgs(model),
+			options: lspFormattingOptions(options)
+		});
+		return LspToMonaco.textEdits(edits);
+	} });
+	monaco.languages.registerDocumentHighlightProvider("typespec", { async provideDocumentHighlights(model, position) {
+		return (await serverLib.findDocumentHighlight(lspArgs(model, position))).map(monacoDocumentHighlight);
+	} });
+	monaco.languages.registerCompletionItemProvider("typespec", {
+		triggerCharacters: lsConfig.capabilities.completionProvider.triggerCharacters,
+		async provideCompletionItems(model, position) {
+			const result = await serverLib.complete(lspArgs(model, position));
+			const word = model.getWordUntilPosition(position);
+			const range = {
+				startLineNumber: position.lineNumber,
+				endLineNumber: position.lineNumber,
+				startColumn: word.startColumn,
+				endColumn: word.endColumn
+			};
+			const suggestions = [];
+			for (const item of result.items) {
+				let itemRange = range;
+				let insertText = item.insertText ?? item.label;
+				if (item.textEdit && "range" in item.textEdit) {
+					itemRange = LspToMonaco.range(item.textEdit.range);
+					insertText = item.textEdit.newText;
+				}
+				suggestions.push({
+					label: item.label,
+					kind: item.kind,
+					documentation: item.documentation,
+					insertText,
+					range: itemRange,
+					commitCharacters: item.commitCharacters ?? lsConfig.capabilities.completionProvider.allCommitCharacters,
+					tags: item.tags
+				});
+			}
+			return { suggestions };
+		}
+	});
+	monaco.languages.registerCodeActionProvider("typespec", { async provideCodeActions(model, range) {
+		const compiler = _currentCompiler;
+		if (!compiler) return {
+			actions: [],
+			dispose: () => {}
+		};
+		const actions = [];
+		for (const diag of _currentDiagnostics) {
+			if (!diag.codefixes?.length) continue;
+			const loc = compiler.getSourceLocation(diag.target, { locateId: true });
+			if (!loc || loc.file.path !== "/test/main.tsp") continue;
+			if (!monacoRangesOverlap(getMonacoRange(compiler, diag.target), range)) continue;
+			for (const fix of diag.codefixes) {
+				const workspaceEdits = (await compiler.resolveCodeFix(fix)).filter((edit) => edit.file.path === "/test/main.tsp").map((edit) => {
+					const start = edit.file.getLineAndCharacterOfPosition(edit.pos);
+					if (edit.kind === "insert-text") return {
+						resource: model.uri,
+						textEdit: {
+							range: {
+								startLineNumber: start.line + 1,
+								startColumn: start.character + 1,
+								endLineNumber: start.line + 1,
+								endColumn: start.character + 1
+							},
+							text: edit.text
+						},
+						versionId: void 0
+					};
+					else {
+						const end = edit.file.getLineAndCharacterOfPosition(edit.end);
+						return {
+							resource: model.uri,
+							textEdit: {
+								range: {
+									startLineNumber: start.line + 1,
+									startColumn: start.character + 1,
+									endLineNumber: end.line + 1,
+									endColumn: end.character + 1
+								},
+								text: edit.text
+							},
+							versionId: void 0
+						};
+					}
+				});
+				if (workspaceEdits.length > 0) actions.push({
+					title: fix.label,
+					kind: "quickfix",
+					edit: { edits: workspaceEdits }
+				});
+			}
+		}
+		return {
+			actions,
+			dispose: () => {}
+		};
+	} });
+	monaco.editor.defineTheme("typespec", {
+		base: "vs",
+		inherit: true,
+		colors: {},
+		rules: [{
+			token: "macro",
+			foreground: "#800000"
+		}, {
+			token: "function",
+			foreground: "#795E26"
+		}]
+	});
+	monaco.editor.defineTheme("typespec-dark", {
+		base: "vs-dark",
+		inherit: true,
+		colors: {},
+		rules: [{
+			token: "macro",
+			foreground: "#E06C75"
+		}, {
+			token: "function",
+			foreground: "#E06C75"
+		}]
+	});
+	monaco.languages.registerDocumentSemanticTokensProvider("typespec", {
+		getLegend() {
+			const legend = lsConfig.capabilities.semanticTokensProvider.legend;
+			return {
+				tokenModifiers: legend.tokenModifiers,
+				tokenTypes: legend.tokenTypes.map((entry) => {
+					switch (entry) {
+						case "namespace":
+						case "class":
+						case "enum":
+						case "typeParameter":
+						case "struct":
+						case "interface": return "type";
+						case "property":
+						case "enumMember": return "variable";
+						case "docCommentTag": return "keyword";
+						default: return entry;
+					}
+				})
+			};
+		},
+		async provideDocumentSemanticTokens(model) {
+			const result = await serverLib.buildSemanticTokens(lspDocumentArgs(model));
+			return {
+				resultId: result.resultId,
+				data: new Uint32Array(result.data)
+			};
+		},
+		releaseDocumentSemanticTokens() {}
+	});
+}
+function getMonacoRange(typespecCompiler, target) {
+	const loc = typespecCompiler.getSourceLocation(target, { locateId: true });
+	if (loc === void 0 || loc.file.path !== "/test/main.tsp") return {
+		startLineNumber: 1,
+		startColumn: 1,
+		endLineNumber: 1,
+		endColumn: 1
+	};
+	const start = loc.file.getLineAndCharacterOfPosition(loc.pos);
+	const end = loc.file.getLineAndCharacterOfPosition(loc.end);
+	return {
+		startLineNumber: start.line + 1,
+		startColumn: start.character + 1,
+		endLineNumber: end.line + 1,
+		endColumn: end.character + 1
+	};
+}
+function monacoRangesOverlap(a, b) {
+	if (a.endLineNumber < b.startLineNumber || b.endLineNumber < a.startLineNumber) return false;
+	if (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn) return false;
+	if (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn) return false;
+	return true;
+}
+//#endregion
+export { resolveVirtualPath as a, createBrowserHost as i, registerMonacoLanguage as n, debugGlobals as o, updateDiagnosticsForCodeFixes as r, printDebugInfo as s, getMonacoRange as t };