@staticbolt/lsp 1.0.0-beta.12

package/lib/index.mjs

@@ -0,0 +1,903 @@
+import * as vs from "vscode-languageserver/node.js";
+import * as vscode$1 from "vscode-languageserver";
+import vscode, { RequestType } from "vscode-languageserver";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import * as vscodeUri from "vscode-uri";
+import { EventEmitter } from "node:events";
+import * as fs from "node:fs";
+import { globSync, watch } from "node:fs";
+import { access, constants } from "node:fs/promises";
+import * as path$1 from "node:path";
+import path, { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import vscodeHtml from "vscode-html-languageservice";
+import { Resolver } from "@staticbolt/core";
+
+//#region src/helpers/config-loader.ts
+const CONFIG_CANDIDATES = [".staticbolt.ts", ".staticbolt.js"];
+async function findConfigFile(workspaceRoot) {
+	for (const name of CONFIG_CANDIDATES) {
+		const full = join(workspaceRoot, name);
+		try {
+			await access(full, constants.R_OK);
+			return full;
+		} catch {}
+	}
+	return null;
+}
+async function importFresh(absolutePath) {
+	const module_ = await import(`${pathToFileURL(absolutePath).href}?t=${Date.now()}`);
+	if (!("default" in module_)) throw new Error(`Config file "${absolutePath}" has no default export. Use \`export default { … }\`.`);
+	return module_.default;
+}
+var ConfigLoader = class extends EventEmitter {
+	workspaceRoot;
+	configPath = null;
+	watcher = null;
+	current = null;
+	debounceTimer = null;
+	DEBOUNCE_MS = 150;
+	constructor(workspaceRoot) {
+		super();
+		this.workspaceRoot = workspaceRoot;
+	}
+	/** Start watching. Resolves with the initial config (or null if absent). */
+	async start() {
+		this.configPath = await findConfigFile(this.workspaceRoot);
+		if (!this.configPath) return null;
+		await this.load();
+		this.watch(this.configPath);
+		return this.current;
+	}
+	/** Stop watching and release all resources. */
+	dispose() {
+		if (this.debounceTimer !== null) clearTimeout(this.debounceTimer);
+		this.watcher?.close();
+		this.watcher = null;
+	}
+	/** The last successfully loaded config, or null if none loaded yet. */
+	get config() {
+		return this.current;
+	}
+	async load() {
+		if (!this.configPath) return;
+		try {
+			this.current = await importFresh(this.configPath);
+			this.emit("change", this.current);
+		} catch (error) {
+			this.emit("error", error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	watch(configPath) {
+		this.watcher = watch(configPath, { persistent: false }, (event) => {
+			if (event === "rename" || event === "change") this.scheduleReload();
+		});
+		this.watcher.on("error", (error) => this.emit("error", error));
+	}
+	scheduleReload() {
+		if (this.debounceTimer !== null) clearTimeout(this.debounceTimer);
+		this.debounceTimer = setTimeout(async () => {
+			this.debounceTimer = null;
+			if (!this.configPath) return;
+			try {
+				await access(this.configPath, constants.R_OK);
+			} catch {
+				this.emit("error", /* @__PURE__ */ new Error(`Config file was removed: ${this.configPath}`));
+				return;
+			}
+			await this.load();
+		}, this.DEBOUNCE_MS);
+	}
+};
+var ConfigManager = class {
+	console;
+	configs = /* @__PURE__ */ new Map();
+	lspHtmlData = [];
+	constructor(console) {
+		this.console = console;
+	}
+	async get(workspaceRoot) {
+		const configLoader = this.configs.get(workspaceRoot);
+		if (configLoader) {
+			if (!configLoader.config) {
+				this.configs.delete(workspaceRoot);
+				return null;
+			}
+			return configLoader.config;
+		}
+		const newConfigLoader = new ConfigLoader(workspaceRoot);
+		this.configs.set(workspaceRoot, newConfigLoader);
+		newConfigLoader.on("error", (error) => {
+			this.console.error(`Failed to load config file: ${error.message}`);
+		});
+		newConfigLoader.on("change", async (config) => {
+			await this.collectData(config);
+		});
+		await newConfigLoader.start();
+		if (!newConfigLoader.config) return null;
+		return newConfigLoader.config;
+	}
+	dispose() {
+		for (const configLoader of this.configs.values()) configLoader.dispose();
+	}
+	async collectData(config) {
+		this.lspHtmlData = [];
+		for (const pluginOrArray of config.plugins ?? []) {
+			const plugins = Array.isArray(pluginOrArray) ? pluginOrArray : [pluginOrArray];
+			for (const plugin of plugins) if (plugin.lspHtmlData) {
+				const htmlData = await plugin.lspHtmlData();
+				if (htmlData) {
+					htmlDataInjectPluginName(htmlData, plugin.name);
+					this.lspHtmlData.push(htmlData);
+				}
+			}
+		}
+	}
+};
+function htmlDataInjectPluginName(htmlData, pluginName) {
+	for (const tag of htmlData.tags ?? []) {
+		tag.description = replaceDescription(tag.description, pluginName);
+		for (const attribute of tag.attributes ?? []) attribute.description = replaceDescription(attribute.description, pluginName);
+	}
+	for (const attribute of htmlData.globalAttributes ?? []) attribute.description = replaceDescription(attribute.description, pluginName);
+}
+function replaceDescription(description, pluginName) {
+	const info = `_Provided by **staticbolt** \`${pluginName}\` plugin._`;
+	if (!description) return info;
+	if (typeof description === "string") {
+		if (description.includes(info)) return description;
+		return `${description}\n\n${info}`;
+	}
+	if (description.value.includes(info)) return description;
+	description.value = `${description.value}\n\n${info}`;
+	return description;
+}
+
+//#endregion
+//#region src/helpers/find-projects.ts
+function findStaticboltProjects(searchRoots) {
+	const results = [];
+	for (const root of searchRoots) {
+		const rootPath = vscodeUri.URI.parse(root.uri).fsPath;
+		const configs = globSync("**/.staticbolt.{ts,js}", {
+			cwd: rootPath,
+			exclude: ["**/node_modules/**", "**/.git/**"]
+		});
+		for (const configPath of configs) {
+			const absDirectory = path$1.join(rootPath, path$1.dirname(configPath));
+			const projectUri = vscodeUri.URI.file(absDirectory).toString();
+			results.push({
+				name: path$1.basename(absDirectory),
+				uri: projectUri
+			});
+		}
+	}
+	return results;
+}
+
+//#endregion
+//#region src/language-model-cache.ts
+function getLanguageModelCache(maxEntries, cleanupIntervalTimeInSec, parse) {
+	let languageModels = {};
+	let nModels = 0;
+	let cleanupInterval = void 0;
+	if (cleanupIntervalTimeInSec > 0) cleanupInterval = setInterval(() => {
+		const cutoffTime = Date.now() - cleanupIntervalTimeInSec * 1e3;
+		const uris = Object.keys(languageModels);
+		for (const uri of uris) if (languageModels[uri].cTime < cutoffTime) {
+			delete languageModels[uri];
+			nModels--;
+		}
+	}, cleanupIntervalTimeInSec * 1e3);
+	return {
+		get(document) {
+			const version = document.version;
+			const languageId = document.languageId;
+			const languageModelInfo = languageModels[document.uri];
+			if (languageModelInfo && languageModelInfo.version === version && languageModelInfo.languageId === languageId) {
+				languageModelInfo.cTime = Date.now();
+				return languageModelInfo.languageModel;
+			}
+			const languageModel = parse(document);
+			languageModels[document.uri] = {
+				languageModel,
+				version,
+				languageId,
+				cTime: Date.now()
+			};
+			if (!languageModelInfo) nModels++;
+			if (nModels === maxEntries) {
+				let oldestTime = Number.MAX_VALUE;
+				let oldestUri = null;
+				for (const uri in languageModels) {
+					const languageModelInfo = languageModels[uri];
+					if (languageModelInfo.cTime < oldestTime) {
+						oldestUri = uri;
+						oldestTime = languageModelInfo.cTime;
+					}
+				}
+				if (oldestUri) {
+					delete languageModels[oldestUri];
+					nModels--;
+				}
+			}
+			return languageModel;
+		},
+		onDocumentRemoved(document) {
+			const uri = document.uri;
+			if (languageModels[uri]) {
+				delete languageModels[uri];
+				nModels--;
+			}
+		},
+		dispose() {
+			if (cleanupInterval !== void 0) {
+				clearInterval(cleanupInterval);
+				cleanupInterval = void 0;
+				languageModels = {};
+				nModels = 0;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/modes/embedded-support.ts
+const TokenType = vscodeHtml.TokenType;
+const Position = vscodeHtml.Position;
+function getDocumentRegions(languageService, document) {
+	const regions = [];
+	const scanner = languageService.createScanner(document.getText());
+	let lastTagName = "";
+	let lastAttributeName = null;
+	let languageIdFromType = void 0;
+	const importedScripts = [];
+	let token = scanner.scan();
+	while (token !== TokenType.EOS) {
+		switch (token) {
+			case TokenType.StartTag:
+				lastTagName = scanner.getTokenText();
+				lastAttributeName = null;
+				languageIdFromType = "javascript";
+				break;
+			case TokenType.Styles:
+				regions.push({
+					languageId: "css",
+					start: scanner.getTokenOffset(),
+					end: scanner.getTokenEnd()
+				});
+				break;
+			case TokenType.Script:
+				regions.push({
+					languageId: languageIdFromType,
+					start: scanner.getTokenOffset(),
+					end: scanner.getTokenEnd()
+				});
+				break;
+			case TokenType.AttributeName:
+				lastAttributeName = scanner.getTokenText();
+				break;
+			case TokenType.AttributeValue:
+				if (lastAttributeName === "src" && lastTagName.toLowerCase() === "script") {
+					let value = scanner.getTokenText();
+					if (value[0] === "'" || value[0] === "\"") value = value.slice(1, -1);
+					importedScripts.push(value);
+				} else if (lastAttributeName === "type" && lastTagName.toLowerCase() === "script") {
+					const token = scanner.getTokenText();
+					if (/["'](module|(text|application)\/(java|ecma)script|text\/babel)["']/.test(token) || token === "module") languageIdFromType = "javascript";
+					else if (/["']text\/typescript["']/.test(token)) languageIdFromType = "typescript";
+					else languageIdFromType = void 0;
+				} else {
+					const attributeLanguageId = getAttributeLanguage(lastAttributeName);
+					if (attributeLanguageId) {
+						let start = scanner.getTokenOffset();
+						let end = scanner.getTokenEnd();
+						const firstChar = document.getText()[start];
+						if (firstChar === "'" || firstChar === "\"") {
+							start++;
+							end--;
+						}
+						regions.push({
+							languageId: attributeLanguageId,
+							start,
+							end,
+							attributeValue: true
+						});
+					}
+				}
+				lastAttributeName = null;
+				break;
+		}
+		token = scanner.scan();
+	}
+	return {
+		getLanguageRanges: (range) => getLanguageRanges(document, regions, range),
+		getEmbeddedDocument: (languageId, ignoreAttributeValues) => getEmbeddedDocument(document, regions, languageId, ignoreAttributeValues),
+		getLanguageAtPosition: (position) => getLanguageAtPosition(document, regions, position),
+		getLanguagesInDocument: () => getLanguagesInDocument(document, regions),
+		getImportedScripts: () => importedScripts
+	};
+}
+function getLanguageRanges(document, regions, range) {
+	const result = [];
+	let currentPos = range ? range.start : Position.create(0, 0);
+	let currentOffset = range ? document.offsetAt(range.start) : 0;
+	const endOffset = range ? document.offsetAt(range.end) : document.getText().length;
+	for (const region of regions) if (region.end > currentOffset && region.start < endOffset) {
+		const start = Math.max(region.start, currentOffset);
+		const startPos = document.positionAt(start);
+		if (currentOffset < region.start) result.push({
+			start: currentPos,
+			end: startPos,
+			languageId: "html"
+		});
+		const end = Math.min(region.end, endOffset);
+		const endPos = document.positionAt(end);
+		if (end > region.start) result.push({
+			start: startPos,
+			end: endPos,
+			languageId: region.languageId,
+			attributeValue: region.attributeValue
+		});
+		currentOffset = end;
+		currentPos = endPos;
+	}
+	if (currentOffset < endOffset) {
+		const endPos = range ? range.end : document.positionAt(endOffset);
+		result.push({
+			start: currentPos,
+			end: endPos,
+			languageId: "html"
+		});
+	}
+	return result;
+}
+function getLanguagesInDocument(_document, regions) {
+	const result = [];
+	for (const region of regions) if (region.languageId && !result.includes(region.languageId)) {
+		result.push(region.languageId);
+		if (result.length === 3) return result;
+	}
+	result.push("html");
+	return result;
+}
+function getLanguageAtPosition(document, regions, position) {
+	const offset = document.offsetAt(position);
+	for (const region of regions) if (region.start <= offset) {
+		if (offset <= region.end) return region.languageId;
+	} else break;
+	return "html";
+}
+function getEmbeddedDocument(document, contents, languageId, ignoreAttributeValues) {
+	let currentPos = 0;
+	const oldContent = document.getText();
+	let result = "";
+	let lastSuffix = "";
+	for (const c of contents) if (c.languageId === languageId && (!ignoreAttributeValues || !c.attributeValue)) {
+		result = substituteWithWhitespace(result, currentPos, c.start, oldContent, lastSuffix, getPrefix(c));
+		result += updateContent(c, oldContent.slice(c.start, c.end));
+		currentPos = c.end;
+		lastSuffix = getSuffix(c);
+	}
+	result = substituteWithWhitespace(result, currentPos, oldContent.length, oldContent, lastSuffix, "");
+	return TextDocument.create(document.uri, languageId, document.version, result);
+}
+function getPrefix(c) {
+	if (c.attributeValue) switch (c.languageId) {
+		case "css": return "__{";
+	}
+	return "";
+}
+function getSuffix(c) {
+	if (c.attributeValue) switch (c.languageId) {
+		case "css": return "}";
+		case "javascript": return ";";
+	}
+	return "";
+}
+function updateContent(c, content) {
+	if (!c.attributeValue && c.languageId === "javascript") return content.replace(`<!--`, `/* `).replace(`-->`, ` */`);
+	if (c.languageId === "css") return content.replace(/(&quot;|&#34;)/g, (match, _, offset) => {
+		const spaces = " ".repeat(match.length - 1);
+		const afterChar = content[offset + match.length];
+		if (!afterChar || afterChar.includes(" ")) return `${spaces}"`;
+		return `"${spaces}`;
+	});
+	return content;
+}
+function substituteWithWhitespace(result, start, end, oldContent, before, after) {
+	result += before;
+	let accumulatedWS = -before.length;
+	for (let index = start; index < end; index++) {
+		const ch = oldContent[index];
+		if (ch === "\n" || ch === "\r") {
+			accumulatedWS = 0;
+			result += ch;
+		} else accumulatedWS++;
+	}
+	result = append(result, " ", accumulatedWS - after.length);
+	result += after;
+	return result;
+}
+function append(result, string_, n) {
+	while (n > 0) {
+		if (n & 1) result += string_;
+		n >>= 1;
+		string_ += string_;
+	}
+	return result;
+}
+function getAttributeLanguage(attributeName) {
+	const match = attributeName.match(/^(style)$|^(on\w+)$/i);
+	if (!match) return null;
+	return match[1] ? "css" : "javascript";
+}
+
+//#endregion
+//#region src/modes/html-mode.ts
+function getHTMLMode(htmlLanguageService) {
+	const htmlDocuments = getLanguageModelCache(10, 60, (document) => htmlLanguageService.parseHTMLDocument(document));
+	return {
+		getId() {
+			return "html";
+		},
+		async doComplete(document, position, documentContext, htmlData) {
+			setHtmlDataProviders(htmlLanguageService, htmlData);
+			const htmlDocument = htmlDocuments.get(document);
+			const completionList = await htmlLanguageService.doComplete2(document, position, htmlDocument, documentContext);
+			for (const item of completionList.items) item.sortText = "0_" + item.label;
+			return completionList;
+		},
+		async doHover(document, position, htmlData) {
+			setHtmlDataProviders(htmlLanguageService, htmlData);
+			return htmlLanguageService.doHover(document, position, htmlDocuments.get(document));
+		},
+		async onDocumentRemoved(document) {
+			htmlDocuments.onDocumentRemoved(document);
+		},
+		async findDocumentLinks(document, documentContext, projectRoot) {
+			const resolver = new Resolver(projectRoot);
+			const documentFs = vscodeUri.URI.parse(document.uri).fsPath;
+			const projectRootRelative = path.relative(projectRoot, documentFs);
+			const links = htmlLanguageService.findDocumentLinks(document, documentContext);
+			for (const link of links) {
+				if (!link.target) continue;
+				const linkFs = vscodeUri.URI.parse(link.target ?? "").fsPath;
+				const source = path.relative(path.dirname(documentFs), linkFs);
+				const resolved = resolver.resolve(source, projectRootRelative);
+				if (resolved) link.target = vscodeUri.URI.file(resolved.path).toString();
+			}
+			return links;
+		},
+		dispose() {
+			htmlDocuments.dispose();
+		}
+	};
+}
+function setHtmlDataProviders(htmlLanguageService, htmlData) {
+	htmlLanguageService.setDataProviders(false, [{
+		getId() {
+			return FILE_PROTOCOL;
+		},
+		isApplicable(languageId) {
+			return languageId === "html";
+		},
+		provideValues(tag, attribute) {
+			const attributes = htmlData.flatMap((data) => data.tags?.filter((t) => t.name === tag) ?? []).flatMap((t) => t.attributes?.filter((a) => a.name === attribute) ?? []);
+			return [...htmlData.flatMap((data) => data.globalAttributes?.filter((a) => a.name === attribute) ?? []), ...attributes].flatMap((a) => a.values ?? []);
+		},
+		provideTags() {
+			return htmlData.flatMap((data) => data.tags ?? []);
+		},
+		provideAttributes(tag) {
+			const tags = htmlData.flatMap((data) => data.tags?.filter((t) => t.name === tag) ?? []);
+			const globalAttributes = htmlData.flatMap((data) => data.globalAttributes ?? []);
+			const attributes = tags.flatMap((t) => t.attributes ?? []);
+			return [...globalAttributes, ...attributes];
+		}
+	}]);
+}
+
+//#endregion
+//#region src/modes/language-modes.ts
+const FILE_PROTOCOL = "staticbolt-server";
+function getLanguageModes(clientCapabilities, requestService) {
+	const htmlLanguageService = vscodeHtml.getLanguageService({
+		clientCapabilities,
+		fileSystemProvider: requestService,
+		customDataProviders: [{
+			getId() {
+				return FILE_PROTOCOL;
+			},
+			isApplicable(languageId) {
+				return languageId === "html";
+			},
+			provideValues(tag, attribute) {
+				return [{ name: `tag:${tag} attribute:${attribute}` }];
+			},
+			provideTags() {
+				return [{
+					name: "staticbolt",
+					description: "# staticbolt-description",
+					attributes: []
+				}];
+			},
+			provideAttributes(tag) {
+				if (tag === "staticbolt") return [{
+					name: "staticbolt-attribute",
+					description: "# staticbolt-attribute-description",
+					values: [{ name: "staticbolt-attribute-value" }]
+				}];
+				return [{ name: "global-attribute" }];
+			}
+		}],
+		useDefaultDataProvider: false
+	});
+	const documentRegions = getLanguageModelCache(10, 60, (document) => getDocumentRegions(htmlLanguageService, document));
+	let modelCaches = [documentRegions];
+	let modes = Object.create(null);
+	modes["html"] = getHTMLMode(htmlLanguageService);
+	return {
+		async updateDataProviders(dataProviders) {
+			htmlLanguageService.setDataProviders(true, dataProviders);
+		},
+		getModeAtPosition(document, position) {
+			const languageId = documentRegions.get(document).getLanguageAtPosition(position);
+			if (languageId) return modes[languageId];
+		},
+		getModesInRange(document, range) {
+			return documentRegions.get(document).getLanguageRanges(range).map((r) => {
+				return {
+					start: r.start,
+					end: r.end,
+					mode: r.languageId ? modes[r.languageId] : void 0,
+					attributeValue: r.attributeValue
+				};
+			});
+		},
+		getAllModesInDocument(document) {
+			const result = [];
+			for (const languageId of documentRegions.get(document).getLanguagesInDocument()) {
+				const mode = modes[languageId];
+				if (mode) result.push(mode);
+			}
+			return result;
+		},
+		getAllModes() {
+			const result = [];
+			for (const languageId in modes) {
+				const mode = modes[languageId];
+				if (mode) result.push(mode);
+			}
+			return result;
+		},
+		getMode(languageId) {
+			return modes[languageId];
+		},
+		onDocumentRemoved(document) {
+			for (const mc of modelCaches) mc.onDocumentRemoved(document);
+			for (const mode in modes) modes[mode].onDocumentRemoved(document);
+		},
+		dispose() {
+			for (const mc of modelCaches) mc.dispose();
+			modelCaches = [];
+			for (const mode in modes) modes[mode].dispose();
+			modes = {};
+		}
+	};
+}
+
+//#endregion
+//#region src/requests.ts
+const FsStatRequest = { type: new RequestType("fs/stat") };
+const FsReadDirectoryRequest = { type: new RequestType("fs/readDir") };
+const FileType$1 = Object.freeze({
+	/** The file type is unknown. */
+	Unknown: 0,
+	/** A regular file. */
+	File: 1,
+	/** A directory. */
+	Directory: 2,
+	/** A symbolic link to a file. */
+	SymbolicLink: 64
+});
+function getFileSystemProvider(handledSchemas, connection, runtime) {
+	const fileFs = runtime.fileFs && handledSchemas.includes("file") ? runtime.fileFs : void 0;
+	return {
+		async stat(uri) {
+			if (fileFs && uri.startsWith("file:")) return fileFs.stat(uri);
+			return await connection.sendRequest(FsStatRequest.type, uri.toString());
+		},
+		readDirectory(uri) {
+			if (fileFs && uri.startsWith("file:")) return fileFs.readDirectory(uri);
+			return connection.sendRequest(FsReadDirectoryRequest.type, uri.toString());
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/arrays.ts
+function pushAll(to, from) {
+	if (from) for (const item of from) to.push(item);
+}
+
+//#endregion
+//#region src/utils/strings.ts
+function startsWith(haystack, needle) {
+	if (haystack.length < needle.length) return false;
+	for (let index = 0; index < needle.length; index++) if (haystack[index] !== needle[index]) return false;
+	return true;
+}
+function endsWith(haystack, needle) {
+	const diff = haystack.length - needle.length;
+	if (diff > 0) return haystack.indexOf(needle, diff) === diff;
+	if (diff === 0) return haystack === needle;
+	return false;
+}
+const CR = "\r".codePointAt(0);
+const NL = "\n".codePointAt(0);
+
+//#endregion
+//#region src/utils/document-context.ts
+function getDocumentContext(documentUri, workspaceFolders) {
+	function getRootFolder() {
+		for (const folder of workspaceFolders) {
+			let folderURI = folder.uri;
+			if (!endsWith(folderURI, "/")) folderURI = folderURI + "/";
+			if (startsWith(documentUri, folderURI)) return folderURI;
+		}
+	}
+	return { resolveReference: (reference, base = documentUri) => {
+		if (/^\w[\w\d+.-]*:/.test(reference)) return reference;
+		if (reference[0] === "/") {
+			const folderUri = getRootFolder();
+			if (folderUri) return folderUri + reference.slice(1);
+		}
+		const baseUri = vscodeUri.URI.parse(base);
+		const baseUriDirectory = baseUri.path.endsWith("/") ? baseUri : vscodeUri.Utils.dirname(baseUri);
+		return vscodeUri.Utils.resolvePath(baseUriDirectory, reference).toString(true);
+	} };
+}
+
+//#endregion
+//#region src/utils/find-project-root.ts
+function findProjectRoot(fileUri) {
+	let directory = path$1.dirname(vscodeUri.URI.parse(fileUri).fsPath);
+	while (true) {
+		for (const config of [".staticbolt.ts", ".staticbolt.js"]) if (fs.existsSync(path$1.join(directory, config))) return directory;
+		const parent = path$1.dirname(directory);
+		if (parent === directory) return null;
+		directory = parent;
+	}
+}
+
+//#endregion
+//#region src/utils/runner.ts
+function formatError(message, error) {
+	if (error instanceof Error) return `${message}: ${error.message}\n${error.stack}`;
+	if (typeof error === "string") return `${message}: ${error}`;
+	if (error) return `${message}: ${error.toString()}`;
+	return message;
+}
+function runSafe(runtime, function_, errorValue, errorMessage, token) {
+	return new Promise((resolve) => {
+		runtime.timer.setImmediate(() => {
+			if (token.isCancellationRequested) {
+				resolve(cancelValue());
+				return;
+			}
+			return function_().then((result) => {
+				if (token.isCancellationRequested) {
+					resolve(cancelValue());
+					return;
+				}
+				resolve(result);
+			}, (error) => {
+				console.error(formatError(errorMessage, error));
+				resolve(errorValue);
+			});
+		});
+	});
+}
+function cancelValue() {
+	return new vscode.ResponseError(vscode.LSPErrorCodes.RequestCancelled, "Request cancelled");
+}
+
+//#endregion
+//#region src/html-server.ts
+function startServer(connection, runtime) {
+	const documents = new vscode$1.TextDocuments(TextDocument);
+	documents.listen(connection);
+	let lspSearchRoots = [];
+	let workspaceFolders = [];
+	let configManager;
+	let languageModes;
+	const documentSettings = {};
+	documents.onDidClose((document) => {
+		delete documentSettings[document.document.uri];
+	});
+	connection.onInitialize((parameters) => {
+		if (Array.isArray(parameters.workspaceFolders)) lspSearchRoots = parameters.workspaceFolders;
+		else {
+			lspSearchRoots = [];
+			if (parameters.rootPath) lspSearchRoots.push({
+				name: "",
+				uri: vscodeUri.URI.file(parameters.rootPath).toString()
+			});
+		}
+		workspaceFolders = findStaticboltProjects(lspSearchRoots);
+		connection.console.log(`[staticbolt] discovered projects:\n` + workspaceFolders.map((f) => `  - [${f.name}]:  ${f.uri}`).join("\n"));
+		const fileSystemProvider = getFileSystemProvider(["file"], connection, runtime);
+		languageModes = getLanguageModes(parameters.capabilities, fileSystemProvider);
+		configManager = new ConfigManager(connection.console);
+		documents.onDidClose((document) => {
+			languageModes.onDocumentRemoved(document.document);
+		});
+		connection.onShutdown(() => {
+			languageModes.dispose();
+			configManager.dispose();
+		});
+		return { capabilities: {
+			textDocumentSync: vscode$1.TextDocumentSyncKind.Incremental,
+			completionProvider: {
+				resolveProvider: true,
+				triggerCharacters: [
+					".",
+					":",
+					"<",
+					"\"",
+					"=",
+					"/"
+				]
+			},
+			hoverProvider: true,
+			documentLinkProvider: { resolveProvider: false }
+		} };
+	});
+	connection.onInitialized(() => {});
+	connection.onCompletion(async (textDocumentPosition, token) => {
+		return runSafe(runtime, async () => {
+			const projectRoot = findProjectRoot(textDocumentPosition.textDocument.uri);
+			if (!projectRoot) return null;
+			const document = documents.get(textDocumentPosition.textDocument.uri);
+			if (!document) return null;
+			const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
+			if (!mode?.doComplete) return {
+				isIncomplete: true,
+				items: []
+			};
+			if (!await configManager.get(projectRoot)) return {
+				isIncomplete: true,
+				items: []
+			};
+			const documentContext = getDocumentContext(document.uri, workspaceFolders);
+			return mode.doComplete(document, textDocumentPosition.position, documentContext, configManager.lspHtmlData);
+		}, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
+	});
+	connection.onCompletionResolve((item, token) => {
+		return runSafe(runtime, async () => {
+			const data = item.data;
+			if (!isCompletionItemData(data)) return item;
+			const document = documents.get(data.uri);
+			if (!document) return item;
+			const mode = languageModes.getMode(data.languageId);
+			if (!mode?.doResolve) return item;
+			return mode.doResolve(document, item);
+		}, item, `Error while resolving completion proposal`, token);
+	});
+	connection.onHover((textDocumentPosition, token) => {
+		return runSafe(runtime, async () => {
+			const projectRoot = findProjectRoot(textDocumentPosition.textDocument.uri);
+			if (!projectRoot) return null;
+			const document = documents.get(textDocumentPosition.textDocument.uri);
+			if (!document) return null;
+			const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
+			if (!mode?.doHover) return null;
+			if (!await configManager.get(projectRoot)) return null;
+			return mode.doHover(document, textDocumentPosition.position, configManager.lspHtmlData);
+		}, null, `Error while computing hover for ${textDocumentPosition.textDocument.uri}`, token);
+	});
+	connection.onDocumentLinks((documentLinkParameter, token) => {
+		return runSafe(runtime, async () => {
+			const projectRoot = findProjectRoot(documentLinkParameter.textDocument.uri);
+			if (!projectRoot) return null;
+			const document = documents.get(documentLinkParameter.textDocument.uri);
+			if (!document) return [];
+			const links = [];
+			const documentContext = getDocumentContext(document.uri, workspaceFolders);
+			for (const mode of languageModes.getAllModesInDocument(document)) if (mode.findDocumentLinks) pushAll(links, await mode.findDocumentLinks(document, documentContext, projectRoot));
+			return links;
+		}, [], `Error while document links for ${documentLinkParameter.textDocument.uri}`, token);
+	});
+	connection.listen();
+}
+function isCompletionItemData(value) {
+	return value && typeof value.languageId === "string" && typeof value.uri === "string" && typeof value.offset === "number";
+}
+
+//#endregion
+//#region src/utils/node-fs.ts
+const FileType = Object.freeze({
+	/** The file type is unknown. */
+	Unknown: 0,
+	/** A regular file. */
+	File: 1,
+	/** A directory. */
+	Directory: 2,
+	/** A symbolic link to a file. */
+	SymbolicLink: 64
+});
+function getNodeFileFS() {
+	function ensureFileUri(location) {
+		if (!location.startsWith("file:")) throw new Error("fileSystemProvider can only handle file URLs");
+	}
+	return {
+		stat(location) {
+			ensureFileUri(location);
+			return new Promise((c, error_) => {
+				const uri = vscodeUri.URI.parse(location);
+				fs.stat(uri.fsPath, (error, stats) => {
+					if (error) return error.code === "ENOENT" ? c({
+						type: FileType.Unknown,
+						ctime: -1,
+						mtime: -1,
+						size: -1
+					}) : error_(error);
+					let type = FileType.Unknown;
+					if (stats.isFile()) type = FileType.File;
+					else if (stats.isDirectory()) type = FileType.Directory;
+					else if (stats.isSymbolicLink()) type = FileType.SymbolicLink;
+					c({
+						type,
+						ctime: stats.ctime.getTime(),
+						mtime: stats.mtime.getTime(),
+						size: stats.size
+					});
+				});
+			});
+		},
+		readDirectory(location) {
+			ensureFileUri(location);
+			return new Promise((c, error_) => {
+				const path = vscodeUri.URI.parse(location).fsPath;
+				fs.readdir(path, { withFileTypes: true }, (error, children) => {
+					if (error) return error_(error);
+					c(children.map((stat) => {
+						if (stat.isSymbolicLink()) return [stat.name, FileType.SymbolicLink];
+						else if (stat.isDirectory()) return [stat.name, FileType.Directory];
+						else if (stat.isFile()) return [stat.name, FileType.File];
+						else return [stat.name, FileType.Unknown];
+					}));
+				});
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const connection = vs.createConnection();
+console.log = connection.console.log.bind(connection.console);
+console.error = connection.console.error.bind(connection.console);
+process.on("unhandledRejection", (error) => {
+	connection.console.error(formatError(`Unhandled exception`, error));
+});
+const runtime = {
+	timer: {
+		setImmediate(callback, ...arguments_) {
+			const handle = setImmediate(callback, ...arguments_);
+			return { dispose: () => clearImmediate(handle) };
+		},
+		setTimeout(callback, ms, ...arguments_) {
+			const handle = setTimeout(callback, ms, ...arguments_);
+			return { dispose: () => clearTimeout(handle) };
+		}
+	},
+	fileFs: getNodeFileFS()
+};
+connection.console.log("[staticbolt] starting server");
+startServer(connection, runtime);
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.mjs.map