@forinda/kickjs-view-language-server 0.1.1 → 0.2.0

package/dist/{server-Dak0ereo.js → server-pe6A1Wn-.js}

@@ -1,5 +1,5 @@
 /**
- * @forinda/kickjs-view-language-server v0.1.1
+ * @forinda/kickjs-view-language-server v0.2.0
  *
  * Copyright (c) Felix Orinda
  *
@@ -53,6 +53,48 @@ function closeParen$1(s, i) {
 	}
 	return s.length;
 }
+/**
+* Where an `@let` value from `from` ends: its `;` outside quotes, as the
+* parser reads it; the line's end while it's unterminated, so typing one
+* doesn't swallow the lines below.
+*/
+function letEnd(s, from) {
+	let quote = "";
+	for (let j = from; j < s.length; j++) {
+		const c = s[j];
+		if (c === "\n") return {
+			at: j,
+			closed: false
+		};
+		if (quote) {
+			if (c === "\\") j++;
+			else if (c === quote) quote = "";
+		} else if (c === "'" || c === "\"") quote = c;
+		else if (c === ";") return {
+			at: j,
+			closed: true
+		};
+	}
+	return {
+		at: s.length,
+		closed: false
+	};
+}
+/** The end of `@verbatim { … }` from `brace` (at `{`): after its `}`, quoted braces skipped as the parser does. */
+function verbatimEnd(s, brace) {
+	let depth = 0;
+	let quote = "";
+	for (let k = brace; k < s.length; k++) {
+		const c = s[k];
+		if (quote) {
+			if (c === "\\") k++;
+			else if (c === quote) quote = "";
+		} else if (c === "'" || c === "\"" || c === "`") quote = c;
+		else if (c === "{") depth++;
+		else if (c === "}" && --depth === 0) return k + 1;
+	}
+	return s.length;
+}
 /** The end of a `{{ … }}` starting at `i`; the text's end when unclosed. */
 function closeInterp(s, i) {
 	let quote = "";
@@ -108,9 +150,9 @@ function scan(s) {
 				const kw = m[1].replace(/\s+/g, " ");
 				let j = i + m[0].length;
 				if (kw === "let" || kw === "input") {
-					const semi = kw === "let" ? s.indexOf(";", j) : -1;
 					const eol = s.indexOf("\n", j);
-					const stop = semi >= 0 && (eol < 0 || semi < eol) ? semi + 1 : eol < 0 ? s.length : eol;
+					const end = kw === "let" ? letEnd(s, j) : void 0;
+					const stop = end ? end.at + (end.closed ? 1 : 0) : eol < 0 ? s.length : eol;
 					out.blank.push([i, stop]);
 					i = stop;
 					continue;
@@ -118,11 +160,7 @@ function scan(s) {
 				if (kw === "verbatim") {
 					const b = skipWs(j);
 					if (s[b] === "{") {
-						let d = 0;
-						let k = b;
-						for (; k < s.length; k++) if (s[k] === "{") d++;
-						else if (s[k] === "}" && --d === 0) break;
-						const stop = Math.min(k + 1, s.length);
+						const stop = verbatimEnd(s, b);
 						out.blank.push([i, stop]);
 						i = stop;
 						continue;
@@ -277,12 +315,38 @@ var KickVirtualCode = class {
 		];
 	}
 };
+/** TS / JS: a code only the kick service plugin reads, for `ctx.render('…')` names. */
+const SCRIPT_IDS = /* @__PURE__ */ new Set([
+	"typescript",
+	"typescriptreact",
+	"javascript",
+	"javascriptreact"
+]);
+const SCRIPT_FILE = /\.(?:[cm]?[jt]s|[jt]sx)$/;
+var RenderCallsCode = class {
+	id = "root";
+	languageId = "kick-render";
+	snapshot;
+	mappings;
+	embeddedCodes = [];
+	constructor(text) {
+		this.snapshot = snapshotOf(text);
+		this.mappings = [{
+			sourceOffsets: [0],
+			generatedOffsets: [0],
+			lengths: [text.length],
+			data: EMBEDDED
+		}];
+	}
+};
 const kickLanguagePlugin = {
 	getLanguageId(uri) {
 		return uri.path.endsWith(".kick") ? "kick" : void 0;
 	},
-	createVirtualCode(_uri, languageId, snapshot) {
-		return languageId === "kick" ? new KickVirtualCode(snapshot.getText(0, snapshot.getLength())) : void 0;
+	createVirtualCode(uri, languageId, snapshot) {
+		const text = snapshot.getText(0, snapshot.getLength());
+		if (languageId === "kick" || uri.path.endsWith(".kick")) return new KickVirtualCode(text);
+		if (SCRIPT_IDS.has(languageId) || SCRIPT_FILE.test(uri.path)) return new RenderCallsCode(text);
 	}
 };
 //#endregion
@@ -295,7 +359,7 @@ const LOOP_VARS = [
 	"$odd",
 	"$count"
 ];
-const IDENT = /[A-Za-z_$][\w$]*/;
+const IDENT$1 = /[A-Za-z_$][\w$]*/;
 /** The end of `(`…`)` from `i` (at `(`), or -1 when it doesn't close before `stop`. */
 function closeParen(s, i, stop) {
 	let depth = 0;
@@ -354,7 +418,7 @@ function scopeAt(s, stop) {
 				const kw = m[1].replace(/\s+/g, " ");
 				let j = i + m[0].length;
 				if (kw === "input") {
-					const name = IDENT.exec(s.slice(j, j + 64));
+					const name = IDENT$1.exec(s.slice(j, j + 64));
 					if (name) inputs.push(name[0]);
 					i = j;
 					continue;
@@ -462,7 +526,7 @@ const KEYWORD = 14;
 const FUNCTION = 3;
 const CLASS = 7;
 const PROPERTY = 10;
-const FILE = 17;
+const FILE$1 = 17;
 const VARIABLE = 6;
 const KEYWORDS = {
 	if: "if (${1:condition}) {\n	$0\n}",
@@ -489,11 +553,19 @@ function componentOf(ws, tag) {
 function layoutSlots(ws, name) {
 	const out = /* @__PURE__ */ new Set();
 	const seen = /* @__PURE__ */ new Set();
-	let layout = name === void 0 ? void 0 : ws.astOf(name)?.layout;
-	while (typeof layout === "string" && !seen.has(layout)) {
+	const chain = [];
+	let layout = name === void 0 ? void 0 : ws.layoutOf(name);
+	while (layout !== void 0 && !seen.has(layout)) {
 		seen.add(layout);
-		const ast = ws.astOf(layout);
-		if (!ast) break;
+		chain.push(layout);
+		layout = ws.layoutOf(layout);
+	}
+	const base = ws.baseLayout();
+	const page = name === void 0 ? void 0 : ws.astOf(name);
+	if (base !== void 0 && name !== void 0 && page?.layout !== null && !name.startsWith(`${ws.componentsDir()}/`) && name !== base && !seen.has(base)) chain.push(base);
+	for (const l of chain) {
+		const ast = ws.astOf(l);
+		if (!ast) continue;
 		const stack = [ast.body];
 		while (stack.length) for (const n of stack.pop()) if (n.k === "slot-outlet") {
 			if (n.name) out.add(n.name);
@@ -503,7 +575,6 @@ function layoutSlots(ws, name) {
 		else if (n.k === "for") stack.push(n.body, n.empty ?? []);
 		else if (n.k === "switch") stack.push(...n.cases.map((c) => c.body), n.default ?? []);
 		else if (n.k === "slot-fill") stack.push(n.body);
-		layout = ast.layout;
 	}
 	return [...out];
 }
@@ -562,7 +633,7 @@ function completions(ws, uri, text, offset) {
 			const dir = ws.componentsDir();
 			return ws.names().filter((n) => !n.startsWith(`${dir}/`)).map((label) => ({
 				label,
-				kind: FILE
+				kind: FILE$1
 			}));
 		}
 		case "slot-name": return layoutSlots(ws, ws.nameOf(uri)).map((label) => ({
@@ -631,7 +702,7 @@ function posOf(text, offset) {
 }
 //#endregion
 //#region src/plugin/definition.ts
-const TOP = {
+const TOP$1 = {
 	start: {
 		line: 0,
 		character: 0
@@ -648,7 +719,7 @@ function definition(ws, _uri, text, offset) {
 		start: posOf(text, start),
 		end: posOf(text, end)
 	};
-	const link = (targetUri, targetRange = TOP) => ({
+	const link = (targetUri, targetRange = TOP$1) => ({
 		originSelectionRange: origin,
 		targetUri,
 		targetRange,
@@ -678,6 +749,75 @@ function definition(ws, _uri, text, offset) {
 	return null;
 }
 //#endregion
+//#region src/plugin/render-calls.ts
+/** A call's template name as typed so far, up to the cursor. */
+const OPEN_CALL = /\b(?:ctx|views)\.render\(\s*(['"`])([^'"`\n]*)$/;
+/** Every call with a literal name. */
+const CALLS = /\b(?:ctx|views)\.render\(\s*(['"`])([^'"`\n]*)\1/g;
+const FILE = 17;
+/** Template names a page can render: everything but components. */
+function renderable(ws) {
+	const dir = `${ws.componentsDir()}/`;
+	return ws.names().filter((n) => !n.startsWith(dir));
+}
+function renderCompletions(ws, text, offset) {
+	const m = OPEN_CALL.exec(text.slice(0, offset));
+	if (!m) return void 0;
+	const range = {
+		start: posOf(text, offset - m[2].length),
+		end: posOf(text, offset)
+	};
+	return renderable(ws).map((name) => ({
+		label: name,
+		kind: FILE,
+		textEdit: {
+			range,
+			newText: name
+		}
+	}));
+}
+/** Calls whose name is a plain literal (not a template string with `${…}`). */
+function calls(text) {
+	return [...text.matchAll(CALLS)].filter((m) => !m[2].includes("${")).map((m) => ({
+		name: m[2],
+		offset: m.index + m[0].length - m[2].length - 1
+	}));
+}
+function renderDefinition(ws, text, offset) {
+	const call = calls(text).find((c) => offset >= c.offset && offset <= c.offset + c.name.length);
+	if (!call || !ws.astOf(call.name)) return null;
+	const top = {
+		start: {
+			line: 0,
+			character: 0
+		},
+		end: {
+			line: 0,
+			character: 0
+		}
+	};
+	return {
+		originSelectionRange: {
+			start: posOf(text, call.offset),
+			end: posOf(text, call.offset + call.name.length)
+		},
+		targetUri: ws.uriOf(call.name),
+		targetRange: top,
+		targetSelectionRange: top
+	};
+}
+function renderDiagnostics(ws, text) {
+	return calls(text).filter((c) => !ws.astOf(c.name)).map((c) => ({
+		range: {
+			start: posOf(text, c.offset),
+			end: posOf(text, c.offset + c.name.length)
+		},
+		severity: 2,
+		source: "kick",
+		message: `template '${c.name}' not found`
+	}));
+}
+//#endregion
 //#region src/plugin/diagnostics.ts
 /** The `.kick` file a root virtual-code document belongs to. */
 function sourceUri(context, uri) {
@@ -692,6 +832,7 @@ function createDiagnosticsPlugin(ws) {
 		} },
 		create(context) {
 			return { provideDiagnostics(document) {
+				if (document.languageId === "kick-render") return renderDiagnostics(ws, document.getText());
 				if (document.languageId !== "kick") return void 0;
 				const uri = sourceUri(context, document.uri);
 				ws.sync(uri, document.getText());
@@ -718,6 +859,421 @@ function formatEdits(view, text, file, tabSize) {
 	}];
 }
 //#endregion
+//#region src/plugin/tokens.ts
+/**
+* Semantic tokens for `.kick` templates, so every LSP editor highlights the
+* template syntax, not only VS Code with its TextMate grammar. Found by a
+* lexical scan, like the language plugin's: the buffer being typed in rarely
+* parses.
+*/
+/** The legend, in order: standard types, so themes colour them. */
+const TOKEN_TYPES = [
+	"keyword",
+	"comment",
+	"operator",
+	"function",
+	"variable",
+	"property",
+	"string",
+	"number",
+	"class",
+	"parameter"
+];
+const LITERALS = /* @__PURE__ */ new Set([
+	"true",
+	"false",
+	"null",
+	"undefined"
+]);
+/** Words with a meaning in block headers: `@for (x of xs; track x.id; let i = $index)`, `@if (a; as b)`, `@layout(none)`. */
+const HEADER_WORDS = /* @__PURE__ */ new Set([
+	"of",
+	"track",
+	"let",
+	"as",
+	"none"
+]);
+function kickTokens(s, isComponent) {
+	const out = [];
+	const push = (offset, length, type) => {
+		if (length > 0) out.push({
+			offset,
+			length,
+			type
+		});
+	};
+	/** An expression in `[from, to)`. */
+	const expr = (from, to, header) => {
+		let prev = "";
+		for (let i = from; i < to;) {
+			const c = s[i];
+			if (/\s/.test(c)) {
+				i++;
+				continue;
+			}
+			if (c === "'" || c === "\"" || c === "`") {
+				let j = i + 1;
+				while (j < to && s[j] !== c) j += s[j] === "\\" ? 2 : 1;
+				j = Math.min(j + 1, to);
+				push(i, j - i, "string");
+				prev = "lit";
+				i = j;
+				continue;
+			}
+			const num = /^\d+(?:\.\d+)?/.exec(s.slice(i, Math.min(to, i + 32)));
+			if (num) {
+				push(i, num[0].length, "number");
+				prev = "lit";
+				i += num[0].length;
+				continue;
+			}
+			const word = /^[A-Za-z_$][\w$]*/.exec(s.slice(i, Math.min(to, i + 128)));
+			if (word) {
+				const w = word[0];
+				const type = prev === "." ? "property" : prev === "|" ? "function" : LITERALS.has(w) || header && HEADER_WORDS.has(w) ? "keyword" : "variable";
+				push(i, w.length, type);
+				prev = "word";
+				i += w.length;
+				continue;
+			}
+			if (c === "|" && s[i + 1] === "|") {
+				prev = "||";
+				i += 2;
+				continue;
+			}
+			if (c === "|") push(i, 1, "operator");
+			prev = c === "?" && s[i + 1] === "." ? "." : c;
+			i += c === "?" && s[i + 1] === "." ? 2 : 1;
+		}
+	};
+	/** `{{ … }}` from `i` (at `{{`); returns its end. */
+	const interp = (i, limit) => {
+		const end = Math.min(closeInterp(s, i), limit);
+		const closed = s.startsWith("}}", end - 2) && end - 2 >= i + 2;
+		push(i, 2, "operator");
+		expr(i + 2, closed ? end - 2 : end, false);
+		if (closed) push(end - 2, 2, "operator");
+		return end;
+	};
+	/** One tag from `i` (at `<`); returns where scanning continues. */
+	const tag = (i) => {
+		const m = /^<(\/?)([A-Za-z][\w:.-]*)/.exec(s.slice(i, i + 64));
+		const name = m[2].toLowerCase();
+		if (isComponent(name)) push(i + 1 + m[1].length, m[2].length, "class");
+		let j = i + m[0].length;
+		while (j < s.length && s[j] !== ">") {
+			const binding = /^\[([^\]\s]+)\]\s*=\s*(["'])/.exec(s.slice(j, j + 128));
+			if (binding) {
+				push(j + 1, binding[1].length, "property");
+				const from = j + binding[0].length;
+				const close = s.indexOf(binding[2], from);
+				const stop = close < 0 ? s.length : close;
+				expr(from, stop, false);
+				j = stop + 1;
+				continue;
+			}
+			const q = s[j];
+			if (q === "\"" || q === "'") {
+				const close = s.indexOf(q, j + 1);
+				const stop = close < 0 ? s.length : close;
+				for (let k = j + 1; k < stop; k++) if (s.startsWith("{{", k)) k = interp(k, stop) - 1;
+				j = stop + 1;
+				continue;
+			}
+			j++;
+		}
+		j = Math.min(j + 1, s.length);
+		if (m[1] || name !== "script" && name !== "style" || s[j - 2] === "/") return j;
+		const close = new RegExp(`</${name}(?=[\\t\\n\\f\\r />])`, "i").exec(s.slice(j));
+		const end = close ? j + close.index : s.length;
+		for (let k = j; k < end; k++) if (s.startsWith("{{", k)) k = interp(k, end) - 1;
+		return end;
+	};
+	let i = 0;
+	while (i < s.length) {
+		const c = s[i];
+		if (s.startsWith("{{--", i)) {
+			const end = s.indexOf("--}}", i + 4);
+			const stop = end < 0 ? s.length : end + 4;
+			push(i, stop - i, "comment");
+			i = stop;
+			continue;
+		}
+		if (s.startsWith("{{", i)) {
+			i = interp(i, s.length);
+			continue;
+		}
+		if (s.startsWith("<!--", i)) {
+			const end = s.indexOf("-->", i + 4);
+			i = end < 0 ? s.length : end + 3;
+			continue;
+		}
+		if (c === "<" && /^<\/?[A-Za-z]/.test(s.slice(i, i + 3))) {
+			i = tag(i);
+			continue;
+		}
+		if (c === "@" && !/[\w@.-]/.test(s[i - 1] ?? "")) {
+			const m = KEYWORD$1.exec(s.slice(i, i + 16));
+			if (m) {
+				const kw = m[1].replace(/\s+/g, " ");
+				push(i, m[0].length, "keyword");
+				let j = i + m[0].length;
+				if (kw === "input" || kw === "let") {
+					const decl = /^\s+([\w$]+)/.exec(s.slice(j, j + 64));
+					if (decl) push(j + decl[0].length - decl[1].length, decl[1].length, kw === "input" ? "parameter" : "variable");
+					const eol = s.indexOf("\n", j);
+					const stop = kw === "let" ? letEnd(s, j).at : eol < 0 ? s.length : eol;
+					const eq = s.indexOf("=", j);
+					if (eq >= 0 && eq < stop) expr(eq + 1, stop, false);
+					i = stop;
+					continue;
+				}
+				while (j < s.length && /\s/.test(s[j])) j++;
+				if (kw === "verbatim" && s[j] === "{") {
+					i = verbatimEnd(s, j);
+					continue;
+				}
+				if (s[j] === "(") {
+					const end = closeParen$1(s, j);
+					expr(j + 1, s[end - 1] === ")" ? end - 1 : end, true);
+					i = end;
+					continue;
+				}
+				i = i + m[0].length;
+				continue;
+			}
+		}
+		i++;
+	}
+	return out;
+}
+//#endregion
+//#region src/plugin/references.ts
+const TOP = {
+	start: {
+		line: 0,
+		character: 0
+	},
+	end: {
+		line: 0,
+		character: 0
+	}
+};
+const IDENT = /^[A-Za-z_$][\w$]*$/;
+const LAYOUT = /@layout\s*\(\s*(['"])([^'"]*)\1/g;
+const rangeOf = (text, offset, length) => ({
+	start: posOf(text, offset),
+	end: posOf(text, offset + length)
+});
+/** The shared name under the cursor, with where it sits in `text`. */
+function targetAt(ws, text, offset) {
+	const t = kickTokens(text, (tag) => componentOf(ws, tag) !== void 0).find((k) => offset >= k.offset && offset <= k.offset + k.length);
+	if (!t) return void 0;
+	const word = text.slice(t.offset, t.offset + t.length);
+	if (t.type === "class") {
+		const name = componentOf(ws, word.toLowerCase());
+		return name === void 0 ? void 0 : {
+			target: {
+				kind: "component",
+				name,
+				tag: word.toLowerCase()
+			},
+			...t
+		};
+	}
+	if (t.type === "function") return {
+		target: {
+			kind: "pipe",
+			name: word
+		},
+		...t
+	};
+	if (t.type === "string" && /@layout\s*\(\s*$/.test(text.slice(0, t.offset))) {
+		const name = word.slice(1, -1);
+		return ws.astOf(name) ? {
+			target: {
+				kind: "layout",
+				name
+			},
+			offset: t.offset + 1,
+			length: name.length
+		} : void 0;
+	}
+}
+/** Every use of `target` in the templates. */
+function usesOf(ws, target) {
+	const out = [];
+	for (const name of ws.names()) {
+		const text = ws.textOf(name);
+		if (text === void 0) continue;
+		const uri = ws.uriOf(name);
+		if (target.kind === "layout") {
+			for (const m of text.matchAll(LAYOUT)) if (m[2] === target.name) out.push({
+				uri,
+				text,
+				offset: m.index + m[0].length - m[2].length - 1,
+				length: m[2].length
+			});
+			continue;
+		}
+		const want = target.kind === "component" ? "class" : "function";
+		const match = target.kind === "component" ? target.tag : target.name;
+		for (const t of kickTokens(text, (tag) => target.kind === "component" && tag === target.tag)) if (t.type === want && text.slice(t.offset, t.offset + t.length).toLowerCase() === match.toLowerCase()) out.push({
+			uri,
+			text,
+			...t
+		});
+	}
+	return out;
+}
+/** Where a pipe is declared in `pipes.ts`; only the forms the server can read. */
+function pipeDeclaration(ws, name) {
+	const decl = ws.pipeDeclaration(name);
+	if (!decl) return void 0;
+	const start = {
+		line: decl.line,
+		character: decl.column
+	};
+	return {
+		uri: URI.file(ws.pipesFile()).toString(),
+		range: {
+			start,
+			end: {
+				line: decl.line,
+				character: decl.column + name.length
+			}
+		}
+	};
+}
+function references(ws, text, offset, includeDeclaration) {
+	const at = targetAt(ws, text, offset);
+	if (!at) return [];
+	const { target } = at;
+	const locations = usesOf(ws, target).map((u) => ({
+		uri: u.uri,
+		range: rangeOf(u.text, u.offset, u.length)
+	}));
+	if (includeDeclaration) {
+		if (target.kind === "pipe") {
+			const decl = pipeDeclaration(ws, target.name);
+			if (decl) locations.push(decl);
+		} else locations.push({
+			uri: ws.uriOf(target.name),
+			range: TOP
+		});
+	}
+	return locations;
+}
+/** What F2 renames here: a pipe, a component tag or a layout name. */
+function renameRange(ws, text, offset) {
+	const at = targetAt(ws, text, offset);
+	if (!at) return void 0;
+	if (at.target.kind === "pipe" && !pipeDeclaration(ws, at.target.name)) return { message: `Rename ${at.target.name} in your pipes file; it isn't declared in a form the editor can rename.` };
+	return rangeOf(text, at.offset, at.length);
+}
+const TAG = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/;
+/** The component file for `tag`, kept in the old one's folder when the tag still starts with it. */
+function componentNameFor(ws, oldName, tag) {
+	if (!TAG.test(tag)) return void 0;
+	const dir = ws.componentsDir();
+	const folders = oldName.slice(dir.length + 1).split("/").slice(0, -1);
+	const prefix = folders.join("-");
+	const name = prefix && tag.startsWith(`${prefix}-`) ? `${dir}/${folders.join("/")}/${tag.slice(prefix.length + 1)}` : `${dir}/${tag}`;
+	return ws.view.componentTag(name, dir) === tag ? name : void 0;
+}
+/** Every use of `target` replaced with `newText`, then the template's file renamed. */
+function renameTemplate(ws, target, newText, newName) {
+	if (target.kind === "pipe") return void 0;
+	if (ws.view.templateName(newName) !== newName || ws.astOf(newName)) return void 0;
+	const byUri = /* @__PURE__ */ new Map();
+	for (const u of usesOf(ws, target)) {
+		const edits = byUri.get(u.uri) ?? [];
+		edits.push({
+			range: rangeOf(u.text, u.offset, u.length),
+			newText
+		});
+		byUri.set(u.uri, edits);
+	}
+	return { documentChanges: [...[...byUri].map(([uri, edits]) => ({
+		textDocument: {
+			uri,
+			version: null
+		},
+		edits
+	})), {
+		kind: "rename",
+		oldUri: ws.uriOf(target.name),
+		newUri: ws.uriOf(newName)
+	}] };
+}
+/** A pipe renamed in every template and in `pipes.ts`; a component or layout, file included. */
+function renameEdits(ws, text, offset, newName) {
+	const at = targetAt(ws, text, offset);
+	if (!at) return void 0;
+	const { target } = at;
+	if (target.kind === "component") {
+		const name = componentNameFor(ws, target.name, newName);
+		return name === void 0 ? void 0 : renameTemplate(ws, target, newName, name);
+	}
+	if (target.kind === "layout") return renameTemplate(ws, target, newName, newName);
+	if (!IDENT.test(newName) || ws.project().pipes.has(newName)) return void 0;
+	const decl = pipeDeclaration(ws, target.name);
+	if (!decl) return void 0;
+	const changes = {};
+	const add = (uri, range) => (changes[uri] ??= []).push({
+		range,
+		newText: newName
+	});
+	for (const u of usesOf(ws, target)) add(u.uri, rangeOf(u.text, u.offset, u.length));
+	add(decl.uri, decl.range);
+	return { changes };
+}
+/**
+* Edits that keep uses pointing at renamed templates: a component's tags, a
+* layout's `@layout('…')`, a page's `ctx.render('…')`. `oldUri` / `newUri`
+* can be a file or a folder.
+*/
+async function fileRenameEdits(ws, oldUri, newUri) {
+	const from = ws.relOf(oldUri)?.replace(/\.kick$/, "");
+	const to = ws.relOf(newUri)?.replace(/\.kick$/, "");
+	if (from === void 0 || to === void 0 || from === to) return void 0;
+	const renamed = /* @__PURE__ */ new Map();
+	for (const name of ws.names()) if (name === from) renamed.set(name, to);
+	else if (name.startsWith(`${from}/`)) renamed.set(name, to + name.slice(from.length));
+	if (!renamed.size) return void 0;
+	const changes = {};
+	const dir = ws.componentsDir();
+	for (const [oldName, newName] of renamed) {
+		const comp = oldName.startsWith(`${dir}/`);
+		const newTag = newName.startsWith(`${dir}/`) ? ws.view.componentTag(newName, dir) : void 0;
+		const targets = [[{
+			kind: "layout",
+			name: oldName
+		}, newName]];
+		if (comp && newTag) targets.push([{
+			kind: "component",
+			name: oldName,
+			tag: ws.view.componentTag(oldName, dir)
+		}, newTag]);
+		for (const [target, newText] of targets) for (const u of usesOf(ws, target)) (changes[u.uri] ??= []).push({
+			range: rangeOf(u.text, u.offset, u.length),
+			newText
+		});
+	}
+	const pages = [...renamed].filter(([n]) => !n.startsWith(`${dir}/`));
+	if (pages.length) {
+		const to = new Map(pages);
+		for (const script of await ws.scripts()) for (const c of calls(script.text)) {
+			const newName = to.get(c.name);
+			if (newName !== void 0) (changes[script.uri] ??= []).push({
+				range: rangeOf(script.text, c.offset, c.name.length),
+				newText: newName
+			});
+		}
+	}
+	return Object.keys(changes).length ? { changes } : void 0;
+}
+//#endregion
 //#region src/plugin/index.ts
 function createKickServicePlugin(ws) {
 	const diagnostics = createDiagnosticsPlugin(ws);
@@ -735,7 +1291,14 @@ function createKickServicePlugin(ws) {
 			] },
 			hoverProvider: true,
 			definitionProvider: true,
-			documentFormattingProvider: true
+			documentFormattingProvider: true,
+			semanticTokensProvider: { legend: {
+				tokenTypes: [...TOKEN_TYPES],
+				tokenModifiers: []
+			} },
+			referencesProvider: true,
+			renameProvider: { prepareProvider: true },
+			fileRenameEditsProvider: true
 		},
 		create(context) {
 			/** The source file's uri and text, with the workspace synced to the buffer. */
@@ -752,6 +1315,13 @@ function createKickServicePlugin(ws) {
 			return {
 				...diagnostics.create(context),
 				provideCompletionItems(document, position) {
+					if (document.languageId === "kick-render") {
+						const items = renderCompletions(ws, document.getText(), document.offsetAt(position));
+						return items && {
+							isIncomplete: false,
+							items
+						};
+					}
 					const d = open(document);
 					if (!d) return void 0;
 					const items = completions(ws, d.uri, d.text, document.offsetAt(position));
@@ -765,10 +1335,51 @@ function createKickServicePlugin(ws) {
 					return d ? hover(ws, d.uri, d.text, document.offsetAt(position)) ?? void 0 : void 0;
 				},
 				provideDefinition(document, position) {
+					if (document.languageId === "kick-render") {
+						const link = renderDefinition(ws, document.getText(), document.offsetAt(position));
+						return link ? [link] : void 0;
+					}
 					const d = open(document);
 					const link = d && definition(ws, d.uri, d.text, document.offsetAt(position));
 					return link ? [link] : void 0;
 				},
+				provideReferences(document, position, context) {
+					const d = open(document);
+					return d ? references(ws, d.text, document.offsetAt(position), context.includeDeclaration) : void 0;
+				},
+				provideRenameRange(document, position) {
+					const d = open(document);
+					return d ? renameRange(ws, d.text, document.offsetAt(position)) : void 0;
+				},
+				provideRenameEdits(document, position, newName) {
+					const d = open(document);
+					return d ? renameEdits(ws, d.text, document.offsetAt(position), newName) : void 0;
+				},
+				provideFileRenameEdits(oldUri, newUri) {
+					return fileRenameEdits(ws, oldUri.toString(), newUri.toString());
+				},
+				provideDocumentSemanticTokens(document, range, legend) {
+					const d = open(document);
+					if (!d) return void 0;
+					const tokens = [];
+					for (const t of kickTokens(d.text, (tag) => componentOf(ws, tag) !== void 0)) {
+						const type = legend.tokenTypes.indexOf(t.type);
+						if (type < 0) continue;
+						let at = t.offset;
+						for (const part of d.text.slice(t.offset, t.offset + t.length).split("\n")) {
+							const p = document.positionAt(at);
+							if (part && p.line >= range.start.line && p.line <= range.end.line) tokens.push([
+								p.line,
+								p.character,
+								part.length,
+								type,
+								0
+							]);
+							at += part.length + 1;
+						}
+					}
+					return tokens;
+				},
 				provideDocumentFormattingEdits(document, _range, options) {
 					const d = open(document);
 					if (!d) return void 0;
@@ -952,6 +1563,11 @@ var Workspace = class {
 		if (rel.startsWith("..") || !rel.endsWith(".kick")) return void 0;
 		return this.opts.view.templateName(rel.slice(0, -5));
 	}
+	/** `uri`'s path inside the views folder (`layouts/main.kick`, `layouts`); `undefined` outside it. */
+	relOf(uri) {
+		const rel = relative(this.opts.viewsDir, URI.parse(uri).fsPath).split(sep).join(posix.sep);
+		return rel.startsWith("..") || isAbsolute(rel) ? void 0 : rel;
+	}
 	nameOf(uri) {
 		return this.nameOfPath(URI.parse(uri).fsPath);
 	}
@@ -1069,6 +1685,7 @@ var Workspace = class {
 	}
 	/** Templates that use `name` as a component or a layout — a layout even after it's gone. */
 	dependentsOf(name) {
+		if (this.configuredLayouts().has(name)) return new Set(this.names().filter((n) => n !== name));
 		const out = /* @__PURE__ */ new Set();
 		const tag = name.startsWith(`${this.opts.componentsDir}/`) ? this.opts.view.componentTag(name, this.opts.componentsDir) : void 0;
 		for (const [n, e] of this.entries) {
@@ -1091,9 +1708,38 @@ var Workspace = class {
 		return {
 			templates: new Map([...this.entries].map(([n, e]) => [n, e.ast])),
 			pipes: new Set(this.pipeNames()),
-			componentsDir: this.opts.componentsDir
+			componentsDir: this.opts.componentsDir,
+			layouts: this.opts.layout,
+			baseLayout: this.opts.baseLayout
 		};
 	}
+	/** Templates that are layouts by configuration: the mapping's targets and the base layout. */
+	configuredLayouts() {
+		const { layout, baseLayout } = this.opts;
+		const out = new Set(typeof layout === "string" ? [layout] : Object.values(layout ?? {}));
+		if (baseLayout) out.add(baseLayout);
+		return out;
+	}
+	scripts() {
+		return this.opts.scripts?.() ?? Promise.resolve([]);
+	}
+	baseLayout() {
+		return this.opts.baseLayout;
+	}
+	/**
+	* The layout `name` renders in: its own `@layout`, else the configured
+	* mapping's longest matching folder prefix (pages only, as `check` does).
+	*/
+	layoutOf(name) {
+		const ast = this.astOf(name);
+		if (!ast) return void 0;
+		if (ast.layout !== void 0) return ast.layout ?? void 0;
+		const { layout } = this.opts;
+		if (layout === void 0 || name.startsWith(`${this.opts.componentsDir}/`) || this.configuredLayouts().has(name)) return void 0;
+		if (typeof layout === "string") return layout;
+		const hit = Object.keys(layout).toSorted((a, b) => b.length - a.length).find((p) => p === "" || name === p || name.startsWith(`${p}/`));
+		return hit === void 0 ? void 0 : layout[hit];
+	}
 	/** Parse errors, else everything `check` reports — as LSP diagnostics. */
 	diagnosticsFor(uri) {
 		const name = this.nameOf(uri);
@@ -1126,6 +1772,47 @@ async function listKick(dir) {
 		return [];
 	}
 }
+const SKIP = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"coverage",
+	"out"
+]);
+const SCRIPT = /\.(?:[cm]?[jt]s|[jt]sx)$/;
+/** TS / JS files under `root`, for `ctx.render('…')` names: no dependencies, build output, dot folders or `.d.ts`. */
+async function listScripts(root) {
+	const out = [];
+	const walk = async (dir) => {
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of entries) {
+			if (e.name.startsWith(".") || SKIP.has(e.name)) continue;
+			const p = join(dir, e.name);
+			if (e.isDirectory()) await walk(p);
+			else if (SCRIPT.test(e.name) && !e.name.endsWith(".d.ts")) out.push(p);
+		}
+	};
+	await walk(root);
+	return out;
+}
+/** `fn` over `items` with at most `limit` running at once, results in order. */
+async function mapLimit(items, limit, fn) {
+	const out = Array.from({ length: items.length });
+	let next = 0;
+	const worker = async () => {
+		while (next < items.length) {
+			const i = next++;
+			out[i] = await fn(items[i]);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+	return out;
+}
 /** What the server watches: every template, and the pipes file wherever it's configured. */
 function watchPatterns(root, pipesFile) {
 	const patterns = ["**/*.kick", "**/pipes.{ts,js}"];
@@ -1155,14 +1842,23 @@ function startServer() {
 			pipesFile,
 			view,
 			read: (p) => readFile(p, "utf8").catch(() => void 0),
-			list: listKick
+			list: listKick,
+			layout: opts.layout || void 0,
+			baseLayout: opts.baseLayout || void 0,
+			scripts: async () => mapLimit(await listScripts(root), 64, async (p) => {
+				const uri = URI.file(p).toString();
+				return {
+					uri,
+					text: server.documents.get(URI.parse(uri))?.getText() ?? await readFile(p, "utf8").catch(() => "")
+				};
+			})
 		});
 		await ws.load();
 		return server.initialize(params, createSimpleProject([kickLanguagePlugin]), [
+			createKickServicePlugin(ws),
 			create$2(),
 			create(),
-			create$1(),
-			createKickServicePlugin(ws)
+			create$1()
 		]);
 	});
 	connection.onInitialized(() => {
@@ -1179,7 +1875,7 @@ function startServer() {
 		await server.languageFeatures.requestRefresh(false);
 	});
 	server.documents.onDidChangeContent(({ document }) => {
-		if (document.languageId === "kick") ws?.sync(document.uri, document.getText());
+		if (document.uri.endsWith(".kick")) ws?.sync(document.uri, document.getText());
 	});
 	server.documents.onDidClose(async ({ document }) => {
 		if (!ws) return;
@@ -1191,9 +1887,17 @@ function startServer() {
 		const dir = `${ws.componentsDir()}/`;
 		return ws.names().filter((n) => !n.startsWith(dir));
 	});
+	connection.onRequest("kick/renderDefinition", ({ text, offset }) => {
+		const link = ws && renderDefinition(ws, text, offset);
+		return link ? {
+			uri: link.targetUri,
+			range: link.originSelectionRange
+		} : null;
+	});
+	connection.onRequest("kick/renderDiagnostics", ({ text }) => ws ? renderDiagnostics(ws, text) : []);
 	connection.onShutdown(() => server.shutdown());
 }
 //#endregion
 export { KickVirtualCode as a, createKickServicePlugin as i, Workspace as n, kickLanguagePlugin as o, loadViewModule as r, startServer as t };
 
-//# sourceMappingURL=server-Dak0ereo.js.map
+//# sourceMappingURL=server-pe6A1Wn-.js.map