@staticbolt/lsp 1.0.0-beta.25 → 1.0.0-beta.27

package/lib/index.mjs

@@ -1,3 +1,4 @@
+import { format, stripVTControlCharacters } from "node:util";
 import * as vs from "vscode-languageserver/node";
 import * as vscode$1 from "vscode-languageserver";
 import vscode, { RequestType } from "vscode-languageserver";
@@ -11,10 +12,12 @@ 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 { markdownToMdast } from "satteri";
 import { Resolver } from "@staticbolt/core";
 
 //#region src/helpers/config-loader.ts
-const CONFIG_CANDIDATES = [".staticbolt.ts", ".staticbolt.js"];
+/** Iterated in order, so the first one that exists wins. */
+const CONFIG_CANDIDATES = /* @__PURE__ */ new Set([".staticbolt.ts", ".staticbolt.js"]);
 async function findConfigFile(workspaceRoot) {
 	for (const name of CONFIG_CANDIDATES) {
 		const full = join(workspaceRoot, name);
@@ -46,7 +49,7 @@ var ConfigLoader = class extends EventEmitter {
 		this.configPath = await findConfigFile(this.workspaceRoot);
 		if (!this.configPath) return null;
 		await this.load();
-		this.watch(this.configPath);
+		this.watch();
 		return this.current;
 	}
 	/** Stop watching and release all resources. */
@@ -68,9 +71,13 @@ var ConfigLoader = class extends EventEmitter {
 			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();
+	/**
+	* The directory is watched rather than the file. A watch on the file itself is bound to the inode, so an editor saving through
+	* a temporary file and a rename leaves it watching a replaced file, and on macOS it never reports a plain write either.
+	*/
+	watch() {
+		this.watcher = watch(this.workspaceRoot, { persistent: false }, (_event, filename) => {
+			if (typeof filename === "string" && CONFIG_CANDIDATES.has(filename)) this.scheduleReload();
 		});
 		this.watcher.on("error", (error) => this.emit("error", error));
 	}
@@ -78,11 +85,9 @@ var ConfigLoader = class extends EventEmitter {
 		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}`));
+			this.configPath = await findConfigFile(this.workspaceRoot);
+			if (!this.configPath) {
+				this.emit("error", /* @__PURE__ */ new Error(`Config file was removed from: ${this.workspaceRoot}`));
 				return;
 			}
 			await this.load();
@@ -121,7 +126,7 @@ var ConfigManager = class {
 		for (const configLoader of this.configs.values()) configLoader.dispose();
 	}
 	async collectData(config) {
-		this.lspHtmlData = [];
+		const collected = [];
 		const plugins = config.plugins ?? [];
 		for (const pluginOrArray of plugins) {
 			const plugins = Array.isArray(pluginOrArray) ? pluginOrArray : [pluginOrArray];
@@ -130,10 +135,11 @@ var ConfigManager = class {
 				const htmlData = await plugin.lspHtmlData();
 				if (htmlData) {
 					htmlDataInjectPluginName(htmlData, plugin.name);
-					this.lspHtmlData.push(htmlData);
+					collected.push(htmlData);
 				}
 			}
 		}
+		this.lspHtmlData = collected;
 	}
 };
 function htmlDataInjectPluginName(htmlData, pluginName) {
@@ -245,17 +251,92 @@ function getLanguageModelCache(maxEntries, cleanupIntervalTimeInSec, parse) {
 	};
 }
 
+//#endregion
+//#region src/modes/markdown-regions.ts
+/**
+* Markdown allows raw HTML anywhere, so a ".md" file is served as HTML with the parts that can never be HTML — front matter, code
+* blocks and code spans — blanked out first. Blanking keeps every offset, so positions still point at the same place in the
+* file.
+*/
+/** None of these nest, so the regions they produce never overlap. */
+const NON_HTML_NODES = /* @__PURE__ */ new Set([
+	"code",
+	"inlineCode",
+	"yaml",
+	"toml"
+]);
+/** The regions of a markdown document that must not be treated as HTML, sorted by start offset. */
+function findMarkdownNonHtmlRegions(text) {
+	let tree;
+	try {
+		tree = markdownToMdast(text);
+	} catch (error) {
+		console.warn("[staticbolt] could not parse markdown, its whole content is handled as HTML:", error);
+		return [];
+	}
+	const regions = [];
+	const pending = [tree];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (NON_HTML_NODES.has(node.type)) {
+			const start = node.position?.start.offset;
+			const end = node.position?.end.offset;
+			if (start !== void 0 && end !== void 0) regions.push({
+				start,
+				end
+			});
+			continue;
+		}
+		if ("children" in node) pending.push(...node.children);
+	}
+	return toUtf16Offsets(text, regions.toSorted((a, b) => a.start - b.start));
+}
+/**
+* The parser counts code points, the editor counts UTF-16 code units. The two only drift apart once a character outside the basic
+* plane, an emoji most of the time, sits before a region.
+*/
+function toUtf16Offsets(text, regions) {
+	if (!/[\uD800-\uDBFF]/.test(text)) return regions;
+	const astral = [];
+	let codePoint = 0;
+	for (const character of text) {
+		if (character.length === 2) astral.push(codePoint);
+		codePoint++;
+	}
+	const toUtf16 = (offset) => offset + astral.filter((position) => position < offset).length;
+	return regions.map((region) => ({
+		start: toUtf16(region.start),
+		end: toUtf16(region.end)
+	}));
+}
+/** Replaces every region with spaces, keeping the length of the text and its line breaks. Regions must be sorted and disjoint. */
+function blankRegions(text, regions) {
+	if (regions.length === 0) return text;
+	let result = "";
+	let cursor = 0;
+	for (const region of regions) {
+		result += text.slice(cursor, region.start) + text.slice(region.start, region.end).replaceAll(/[^\n\r]/g, " ");
+		cursor = region.end;
+	}
+	return result + text.slice(cursor);
+}
+
 //#endregion
 //#region src/modes/embedded-support.ts
 const TokenType = vscodeHtml.TokenType;
-const Position = vscodeHtml.Position;
 function getDocumentRegions(languageService, document) {
+	const source = document.getText();
+	const isMarkdown = document.languageId === "markdown";
+	const markdownRegions = isMarkdown ? findMarkdownNonHtmlRegions(source).map((region) => ({
+		...region,
+		languageId: void 0
+	})) : [];
+	const htmlText = isMarkdown ? blankRegions(source, markdownRegions) : source;
 	const regions = [];
-	const scanner = languageService.createScanner(document.getText());
+	const scanner = languageService.createScanner(htmlText);
 	let lastTagName = "";
 	let lastAttributeName = null;
 	let languageIdFromType;
-	const importedScripts = [];
 	let token = scanner.scan();
 	while (token !== TokenType.EOS) {
 		switch (token) {
@@ -282,11 +363,7 @@ function getDocumentRegions(languageService, document) {
 				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") {
+				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";
@@ -296,7 +373,7 @@ function getDocumentRegions(languageService, document) {
 					if (attributeLanguageId) {
 						let start = scanner.getTokenOffset();
 						let end = scanner.getTokenEnd();
-						const firstChar = document.getText()[start];
+						const firstChar = htmlText[start];
 						if (firstChar === "'" || firstChar === "\"") {
 							start++;
 							end--;
@@ -304,8 +381,7 @@ function getDocumentRegions(languageService, document) {
 						regions.push({
 							languageId: attributeLanguageId,
 							start,
-							end,
-							attributeValue: true
+							end
 						});
 					}
 				}
@@ -313,58 +389,30 @@ function getDocumentRegions(languageService, document) {
 		}
 		token = scanner.scan();
 	}
+	const allRegions = mergeRegions(regions, markdownRegions);
+	const htmlDocument = isMarkdown ? TextDocument.create(document.uri, "html", document.version, htmlText) : document;
 	return {
-		getLanguageRanges: (range) => getLanguageRanges(document, regions, range),
-		getEmbeddedDocument: (languageId, shouldIgnoreAttributeValues) => getEmbeddedDocument(document, regions, languageId, shouldIgnoreAttributeValues),
-		getLanguageAtPosition: (position) => getLanguageAtPosition(document, regions, position),
-		getLanguagesInDocument: () => getLanguagesInDocument(document, regions),
-		getImportedScripts: () => importedScripts
+		getLanguageAtPosition: (position) => getLanguageAtPosition(document, allRegions, position),
+		getLanguagesInDocument: () => getLanguagesInDocument(allRegions),
+		getHtmlDocument: () => htmlDocument
 	};
 }
-function getLanguageRanges(document, regions, range) {
+/** The lookups below read the regions in order, so an overlap is dropped: a scanned region always wins over a markdown one. */
+function mergeRegions(scanned, markdown) {
+	if (markdown.length === 0) return scanned;
+	const merged = [...scanned, ...markdown].toSorted((a, b) => a.start - b.start || b.end - a.end);
 	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)) continue;
-		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"
-		});
+	for (const region of merged) {
+		const previous = result.at(-1);
+		if (previous && region.start < previous.end) continue;
+		result.push(region);
 	}
 	return result;
 }
-function getLanguagesInDocument(_document, regions) {
-	const result = [];
-	for (const region of regions) {
-		if (!(region.languageId && !result.includes(region.languageId))) continue;
-		result.push(region.languageId);
-		if (result.length === 3) return result;
-	}
-	result.push("html");
-	return result;
+function getLanguagesInDocument(regions) {
+	const languages = /* @__PURE__ */ new Set(["html"]);
+	for (const region of regions) if (region.languageId) languages.add(region.languageId);
+	return [...languages];
 }
 function getLanguageAtPosition(document, regions, position) {
 	const offset = document.offsetAt(position);
@@ -373,89 +421,216 @@ function getLanguageAtPosition(document, regions, position) {
 	} else break;
 	return "html";
 }
-function getEmbeddedDocument(document, contents, languageId, shouldIgnoreAttributeValues) {
-	let currentPos = 0;
-	const oldContent = document.getText();
-	let result = "";
-	let lastSuffix = "";
-	for (const c of contents) {
-		if (!(c.languageId === languageId && (!shouldIgnoreAttributeValues || !c.attributeValue))) continue;
-		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/helpers/merge-html-data.ts
+/** Separates the documentation of two contributors. Rendered as a horizontal rule, unless the description is plain text. */
+const MARKDOWN_SEPARATOR = "\n\n---\n\n";
+const PLAINTEXT_SEPARATOR = "\n\n";
+/** Groups entries by key, preserving the order of first appearance. */
+function groupBy(items, toKey) {
+	const groups = /* @__PURE__ */ new Map();
+	const ordered = [];
+	for (const item of items) {
+		const key = toKey(item);
+		let group = groups.get(key);
+		if (!group) {
+			group = [];
+			groups.set(key, group);
+			ordered.push(group);
+		}
+		group.push(item);
+	}
+	return ordered;
+}
+/** Markdown wins over plain text, so a contributor asking for rich text still gets it. Plain strings imply no preference. */
+function mergeDescriptionKind(descriptions) {
+	let kind;
+	for (const description of descriptions) {
+		if (typeof description === "string" || kind === "markdown") continue;
+		kind = description.kind;
+	}
+	return kind;
+}
+/** Concatenates every distinct description, so no contributor's documentation gets lost. */
+function mergeDescriptions(descriptions) {
+	const defined = descriptions.filter((description) => description !== void 0);
+	if (defined.length <= 1) return defined[0];
+	const parts = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const description of defined) {
+		const text = (typeof description === "string" ? description : description.value).trim();
+		if (!text || seen.has(text)) continue;
+		seen.add(text);
+		parts.push(text);
+	}
+	if (parts.length === 0) return void 0;
+	const kind = mergeDescriptionKind(defined);
+	const value = parts.join(kind === "plaintext" ? PLAINTEXT_SEPARATOR : MARKDOWN_SEPARATOR);
+	return kind ? {
+		kind,
+		value
+	} : value;
+}
+function mergeReferences(references) {
+	const merged = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const list of references) {
+		const entries = list ?? [];
+		for (const reference of entries) {
+			const key = `${reference.name} ${reference.url}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			merged.push(reference);
+		}
+	}
+	return merged.length > 0 ? merged : void 0;
+}
+function mergeBrowsers(browsers) {
+	const merged = /* @__PURE__ */ new Set();
+	for (const list of browsers) {
+		const entries = list ?? [];
+		for (const browser of entries) merged.add(browser);
+	}
+	return merged.size > 0 ? [...merged] : void 0;
+}
+/** The values an attribute contributes, with its `valueSet` reference expanded. */
+function resolveValues(attribute, valueSets) {
+	const values = attribute.values ?? [];
+	if (!attribute.valueSet) return values;
+	return [...valueSets.get(attribute.valueSet) ?? [], ...values];
+}
+/** Merges entries sharing the same value name into one. Unlike tags and attributes, value names are case-sensitive. */
+function mergeValues(values) {
+	return groupBy(values, (value) => value.name).map((group) => {
+		if (group.length === 1) return group[0];
+		return {
+			name: group[0].name,
+			description: mergeDescriptions(group.map((value) => value.description)),
+			references: mergeReferences(group.map((value) => value.references)),
+			browsers: mergeBrowsers(group.map((value) => value.browsers)),
+			status: group.find((value) => value.status)?.status
+		};
+	});
+}
+/**
+* Merges entries sharing the same attribute name into one, combining their descriptions, values, references and browser support.
+*
+* `valueSet` references are expanded into the merged `values`, so attributes contributed by different plugins can each bring
+* their own value set and still end up with a single, complete value list.
+*/
+function mergeAttributes(attributes, valueSets) {
+	return groupBy(attributes, (attribute) => attribute.name.toLowerCase()).map((group) => {
+		if (group.length === 1 && !group[0].valueSet) return group[0];
+		const values = mergeValues(group.flatMap((attribute) => resolveValues(attribute, valueSets)));
+		return {
+			name: group[0].name,
+			description: mergeDescriptions(group.map((attribute) => attribute.description)),
+			values: values.length > 0 ? values : void 0,
+			references: mergeReferences(group.map((attribute) => attribute.references)),
+			browsers: mergeBrowsers(group.map((attribute) => attribute.browsers)),
+			status: group.find((attribute) => attribute.status)?.status
+		};
+	});
+}
+/** Merges entries sharing the same tag name into one, including their attributes. */
+function mergeTags(tags, valueSets) {
+	return groupBy(tags, (tag) => tag.name.toLowerCase()).map((group) => {
+		const attributes = mergeAttributes(group.flatMap((tag) => tag.attributes ?? []), valueSets);
+		if (group.length === 1) return {
+			...group[0],
+			attributes
+		};
+		return {
+			name: group[0].name,
+			description: mergeDescriptions(group.map((tag) => tag.description)),
+			attributes,
+			references: mergeReferences(group.map((tag) => tag.references)),
+			browsers: mergeBrowsers(group.map((tag) => tag.browsers)),
+			status: group.find((tag) => tag.status)?.status,
+			void: group.some((tag) => tag.void)
+		};
+	});
+}
+/** Value sets sharing a name are merged, so an attribute referencing one gets the values of every contributor. */
+function collectValueSets(htmlData) {
+	const valueSets = /* @__PURE__ */ new Map();
+	const collected = htmlData.flatMap((data) => data.valueSets ?? []);
+	for (const valueSet of collected) {
+		const existing = valueSets.get(valueSet.name);
+		valueSets.set(valueSet.name, existing ? mergeValues([...existing, ...valueSet.values]) : valueSet.values);
+	}
+	return valueSets;
+}
+/**
+* Builds a single data provider out of every collected `HTMLDataV1`, merging tags, attributes and values that share the same name
+* instead of reporting them once per contributor.
+*/
+function createMergedHtmlDataProvider(id, htmlData) {
+	const valueSets = collectValueSets(htmlData);
+	const tags = mergeTags(htmlData.flatMap((data) => data.tags ?? []), valueSets);
+	const globalAttributes = mergeAttributes(htmlData.flatMap((data) => data.globalAttributes ?? []), valueSets);
+	const tagsByName = new Map(tags.map((tag) => [tag.name.toLowerCase(), tag]));
+	const attributesByTag = /* @__PURE__ */ new Map();
+	function provideAttributes(tag) {
+		const key = tag.toLowerCase();
+		const cached = attributesByTag.get(key);
+		if (cached) return cached;
+		const tagAttributes = tagsByName.get(key)?.attributes;
+		if (!tagAttributes || tagAttributes.length === 0) return globalAttributes;
+		const attributes = mergeAttributes([...globalAttributes, ...tagAttributes], valueSets);
+		attributesByTag.set(key, attributes);
+		return attributes;
+	}
+	return {
+		getId() {
+			return id;
+		},
+		isApplicable(languageId) {
+			return languageId === "html";
+		},
+		provideTags() {
+			return tags;
+		},
+		provideAttributes,
+		provideValues(tag, attribute) {
+			const name = attribute.toLowerCase();
+			return provideAttributes(tag).find((a) => a.name.toLowerCase() === name)?.values ?? [];
+		}
+	};
+}
+
 //#endregion
 //#region src/modes/html-mode.ts
 function getHTMLMode(htmlLanguageService) {
 	const htmlDocuments = getLanguageModelCache(10, 60, (document) => htmlLanguageService.parseHTMLDocument(document));
+	let lastHtmlData;
+	let lastProvider;
+	function setHtmlDataProviders(htmlData) {
+		if (!lastProvider || lastHtmlData !== htmlData) {
+			lastHtmlData = htmlData;
+			lastProvider = createMergedHtmlDataProvider(FILE_PROTOCOL, htmlData);
+		}
+		htmlLanguageService.setDataProviders(false, [lastProvider]);
+	}
 	return {
 		getId() {
 			return "html";
 		},
 		async doComplete(document, position, documentContext, htmlData) {
-			setHtmlDataProviders(htmlLanguageService, htmlData);
+			setHtmlDataProviders(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);
+			setHtmlDataProviders(htmlData);
 			return htmlLanguageService.doHover(document, position, htmlDocuments.get(document));
 		},
 		async onDocumentRemoved(document) {
@@ -480,32 +655,12 @@ function getHTMLMode(htmlLanguageService) {
 		}
 	};
 }
-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
+function isCompletionItemData(value) {
+	return value && typeof value.languageId === "string" && typeof value.uri === "string" && typeof value.offset === "number";
+}
 const FILE_PROTOCOL = "staticbolt-server";
 function getLanguageModes(clientCapabilities, requestService) {
 	const htmlLanguageService = vscodeHtml.getLanguageService({
@@ -547,20 +702,13 @@ function getLanguageModes(clientCapabilities, requestService) {
 		async updateDataProviders(dataProviders) {
 			htmlLanguageService.setDataProviders(true, dataProviders);
 		},
+		getHtmlDocument(document) {
+			return documentRegions.get(document).getHtmlDocument();
+		},
 		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()) {
@@ -569,14 +717,6 @@ function getLanguageModes(clientCapabilities, requestService) {
 			}
 			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];
 		},
@@ -718,10 +858,6 @@ function startServer(connection, runtime) {
 	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 {
@@ -776,8 +912,9 @@ function startServer(connection, runtime) {
 				isIncomplete: true,
 				items: []
 			};
+			const htmlDocument = languageModes.getHtmlDocument(document);
 			const documentContext = getDocumentContext(document.uri, workspaceFolders);
-			return mode.doComplete(document, textDocumentPosition.position, documentContext, configManager.lspHtmlData);
+			return mode.doComplete(htmlDocument, textDocumentPosition.position, documentContext, configManager.lspHtmlData);
 		}, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
 	});
 	connection.onCompletionResolve((item, token) => {
@@ -788,7 +925,7 @@ function startServer(connection, runtime) {
 			if (!document) return item;
 			const mode = languageModes.getMode(data.languageId);
 			if (!mode?.doResolve) return item;
-			return mode.doResolve(document, item);
+			return mode.doResolve(languageModes.getHtmlDocument(document), item);
 		}, item, `Error while resolving completion proposal`, token);
 	});
 	connection.onHover((textDocumentPosition, token) => {
@@ -800,7 +937,7 @@ function startServer(connection, runtime) {
 			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);
+			return mode.doHover(languageModes.getHtmlDocument(document), textDocumentPosition.position, configManager.lspHtmlData);
 		}, null, `Error while computing hover for ${textDocumentPosition.textDocument.uri}`, token);
 	});
 	connection.onDocumentLinks((documentLinkParameter, token) => {
@@ -810,16 +947,14 @@ function startServer(connection, runtime) {
 			const document = documents.get(documentLinkParameter.textDocument.uri);
 			if (!document) return [];
 			const links = [];
+			const htmlDocument = languageModes.getHtmlDocument(document);
 			const documentContext = getDocumentContext(document.uri, workspaceFolders);
-			for (const mode of languageModes.getAllModesInDocument(document)) if (mode.findDocumentLinks) pushAll(links, await mode.findDocumentLinks(document, documentContext, projectRoot));
+			for (const mode of languageModes.getAllModesInDocument(document)) if (mode.findDocumentLinks) pushAll(links, await mode.findDocumentLinks(htmlDocument, 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
@@ -882,8 +1017,18 @@ function getNodeFileFS() {
 //#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);
+/**
+* `RemoteConsole` takes a single string, but the shared logger calls `console` with several arguments and colours them with
+* chalk. Passing the methods straight through drops everything after the first argument, and the output panel renders no ANSI —
+* so format the arguments the way `console` would, then strip the escapes.
+*/
+function forward(write) {
+	return (...messages) => write(stripVTControlCharacters(format(...messages)));
+}
+console.log = forward(connection.console.log.bind(connection.console));
+console.info = forward(connection.console.info.bind(connection.console));
+console.warn = forward(connection.console.warn.bind(connection.console));
+console.error = forward(connection.console.error.bind(connection.console));
 process.on("unhandledRejection", (error) => {
 	connection.console.error(formatError(`Unhandled exception`, error));
 });