@forinda/kickjs-view-language-server 0.0.0-stage → 0.1.0

package/dist/server-3edMz3HM.js

@@ -0,0 +1,1157 @@
+/**
+ * @forinda/kickjs-view-language-server v0.1.0
+ *
+ * Copyright (c) Felix Orinda
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { createConnection, createServer, createSimpleProject } from "@volar/language-server/node.js";
+import { create } from "volar-service-css";
+import { create as create$1 } from "volar-service-emmet";
+import { create as create$2 } from "volar-service-html";
+import { URI } from "vscode-uri";
+import { pathToFileURL } from "node:url";
+import * as bundled from "@forinda/kickjs-view";
+//#region src/language-plugin.ts
+const ALL = {
+	verification: true,
+	completion: true,
+	semantic: true,
+	navigation: true,
+	structure: true,
+	format: true
+};
+/** Embedded documents never format: the kick formatter owns the whole file. */
+const EMBEDDED = {
+	...ALL,
+	format: false
+};
+const KEYWORD$1 = /^@(else\s+if|if|for|switch|case|slot|layout|assets|verbatim|let|input|else|empty|default)(?![\w$-])/;
+const snapshotOf = (text) => ({
+	getText: (start, end) => text.slice(start, end),
+	getLength: () => text.length,
+	getChangeRange: () => void 0
+});
+/** The end of a `(`…`)` group starting at `i` (at `(`); the text's end when unclosed. */
+function closeParen$1(s, i) {
+	let depth = 0;
+	let quote = "";
+	for (let j = i; j < s.length; j++) {
+		const c = s[j];
+		if (quote) {
+			if (c === "\\") j++;
+			else if (c === quote) quote = "";
+		} else if (c === "'" || c === "\"") quote = c;
+		else if (c === "(") depth++;
+		else if (c === ")" && --depth === 0) return j + 1;
+	}
+	return s.length;
+}
+/** The end of a `{{ … }}` starting at `i`; the text's end when unclosed. */
+function closeInterp(s, i) {
+	let quote = "";
+	for (let j = i + 2; j < s.length; j++) {
+		const c = s[j];
+		if (quote) {
+			if (c === "\\") j++;
+			else if (c === quote) quote = "";
+		} else if (c === "'" || c === "\"") quote = c;
+		else if (c === "}" && s[j + 1] === "}") return j + 2;
+	}
+	return s.length;
+}
+function scan(s) {
+	const out = {
+		blank: [],
+		styles: [],
+		scripts: []
+	};
+	let depth = 0;
+	let i = 0;
+	const skipWs = (j) => {
+		while (j < s.length && /\s/.test(s[j])) j++;
+		return j;
+	};
+	while (i < s.length) {
+		const c = s[i];
+		if (c === "{" && s.startsWith("{{--", i)) {
+			const end = s.indexOf("--}}", i + 4);
+			const stop = end < 0 ? s.length : end + 4;
+			out.blank.push([i, stop]);
+			i = stop;
+			continue;
+		}
+		if (c === "{" && s[i + 1] === "{") {
+			const stop = closeInterp(s, i);
+			out.blank.push([i, stop]);
+			i = stop;
+			continue;
+		}
+		if (c === "<" && 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(s, i, out);
+			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, " ");
+				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;
+					out.blank.push([i, stop]);
+					i = stop;
+					continue;
+				}
+				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);
+						out.blank.push([i, stop]);
+						i = stop;
+						continue;
+					}
+				}
+				const p = skipWs(j);
+				if (s[p] === "(") j = closeParen$1(s, p);
+				else if (kw !== "else" && kw !== "empty" && kw !== "default") {
+					i++;
+					continue;
+				}
+				if (kw === "layout" || kw === "assets") {
+					out.blank.push([i, j]);
+					i = j;
+					continue;
+				}
+				const b = skipWs(j);
+				if (s[b] === "{") {
+					out.blank.push([i, b + 1]);
+					depth++;
+					i = b + 1;
+					continue;
+				}
+				out.blank.push([i, j]);
+				i = j;
+				continue;
+			}
+		}
+		if (c === "}" && depth > 0) {
+			out.blank.push([i, i + 1]);
+			depth--;
+			i++;
+			continue;
+		}
+		i++;
+	}
+	return out;
+}
+/** One tag from `i` (at `<`): interpolations and binding values blanked; script / style content recorded. */
+function tag(s, i, out) {
+	const m = /^<(\/?)([A-Za-z][\w:.-]*)/.exec(s.slice(i, i + 64));
+	let j = i + m[0].length;
+	const closing = !!m[1];
+	const name = m[2].toLowerCase();
+	let type = "";
+	while (j < s.length && s[j] !== ">") {
+		const binding = /^\[[^\]\s]+\]\s*=\s*(["'])/.exec(s.slice(j, j + 128));
+		if (binding) {
+			const q = binding[1];
+			const from = j + binding[0].length;
+			const end = s.indexOf(q, from);
+			const stop = end < 0 ? s.length : end;
+			out.blank.push([from, stop]);
+			j = stop + 1;
+			continue;
+		}
+		const t = /^type\s*=\s*(["'])([^"']*)\1/i.exec(s.slice(j, j + 128));
+		if (t) type = t[2].trim().toLowerCase();
+		const q = s[j];
+		if (q === "\"" || q === "'") {
+			const end = s.indexOf(q, j + 1);
+			const stop = end < 0 ? s.length : end;
+			for (let k = j + 1; k < stop; k++) if (s[k] === "{" && s[k + 1] === "{") {
+				const e = Math.min(closeInterp(s, k), stop);
+				out.blank.push([k, e]);
+				k = e - 1;
+			}
+			j = stop + 1;
+			continue;
+		}
+		j++;
+	}
+	j = Math.min(j + 1, s.length);
+	if (closing || 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[k] === "{" && s[k + 1] === "{") {
+		const e = Math.min(closeInterp(s, k), end);
+		out.blank.push([k, e]);
+		k = e - 1;
+	}
+	if (name === "style") out.styles.push([j, end]);
+	else if (type !== "application/json" && type !== "application/ld+json") out.scripts.push([j, end]);
+	return end;
+}
+function embedded(id, languageId, text, [from, to]) {
+	return {
+		id,
+		languageId,
+		snapshot: snapshotOf(text.slice(from, to)),
+		mappings: [{
+			sourceOffsets: [from],
+			generatedOffsets: [0],
+			lengths: [to - from],
+			data: EMBEDDED
+		}]
+	};
+}
+var KickVirtualCode = class {
+	text;
+	id = "root";
+	languageId = "kick";
+	snapshot;
+	mappings;
+	embeddedCodes;
+	constructor(text) {
+		this.text = text;
+		this.snapshot = snapshotOf(text);
+		this.mappings = [{
+			sourceOffsets: [0],
+			generatedOffsets: [0],
+			lengths: [text.length],
+			data: ALL
+		}];
+		const { blank, styles, scripts } = scan(text);
+		const sorted = blank.toSorted((a, b) => a[0] - b[0]);
+		let html = "";
+		const htmlMappings = [];
+		let at = 0;
+		const keep = (from, to) => {
+			if (to <= from) return;
+			html += text.slice(from, to);
+			htmlMappings.push({
+				sourceOffsets: [from],
+				generatedOffsets: [from],
+				lengths: [to - from],
+				data: EMBEDDED
+			});
+		};
+		for (const [a, b] of sorted) {
+			if (a < at) {
+				if (b > at) {
+					html += text.slice(at, b).replace(/[^\n\r]/g, " ");
+					at = b;
+				}
+				continue;
+			}
+			keep(at, a);
+			html += text.slice(a, b).replace(/[^\n\r]/g, " ");
+			at = b;
+		}
+		keep(at, text.length);
+		this.embeddedCodes = [
+			{
+				id: "html",
+				languageId: "html",
+				snapshot: snapshotOf(html),
+				mappings: htmlMappings
+			},
+			...styles.map((r, n) => embedded(`css_${n}`, "css", text, r)),
+			...scripts.map((r, n) => embedded(`js_${n}`, "javascript", text, r))
+		];
+	}
+};
+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;
+	}
+};
+//#endregion
+//#region src/context.ts
+const LOOP_VARS = [
+	"$index",
+	"$first",
+	"$last",
+	"$even",
+	"$odd",
+	"$count"
+];
+const IDENT = /[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;
+	let quote = "";
+	for (let j = i; j < stop; j++) {
+		const c = s[j];
+		if (quote) {
+			if (c === "\\") j++;
+			else if (c === quote) quote = "";
+		} else if (c === "'" || c === "\"") quote = c;
+		else if (c === "(") depth++;
+		else if (c === ")" && --depth === 0) return j + 1;
+	}
+	return -1;
+}
+/** Names a block header brings into its body. */
+function headerNames(kw, header) {
+	if (kw === "for") {
+		const [head, ...rest] = header.split(";");
+		const m = /^\s*(?:\[\s*([\w$]+)\s*,\s*([\w$]+)\s*\]|([\w$]+))\s+of\b/.exec(head ?? "");
+		const names = m ? m[3] ? [m[3]] : [m[1], m[2]] : [];
+		for (const part of rest) {
+			const lets = /^\s*let\s+(.*)$/.exec(part);
+			if (lets) for (const d of lets[1].split(",")) names.push(d.split("=")[0].trim());
+		}
+		return [...names.filter(Boolean), ...LOOP_VARS];
+	}
+	if (kw === "if" || kw === "else if") {
+		const as = /;\s*as\s+([\w$]+)/.exec(header);
+		return as ? [as[1]] : [];
+	}
+	return [];
+}
+/** Names in scope at `stop`: inputs, then each enclosing block's, outermost first. */
+function scopeAt(s, stop) {
+	const inputs = [];
+	const frames = [[]];
+	let i = 0;
+	while (i < stop) {
+		const c = s[i];
+		if (c === "{" && s[i + 1] === "{") {
+			const end = s.indexOf(s.startsWith("{{--", i) ? "--}}" : "}}", i + 2);
+			if (end < 0 || end >= stop) break;
+			i = end + 2;
+			continue;
+		}
+		if (c === "<") {
+			const end = s.startsWith("<!--", i) ? s.indexOf("-->", i) : s.indexOf(">", i);
+			if (end < 0 || end >= stop) break;
+			i = end + 1;
+			continue;
+		}
+		if (c === "@" && !/[\w@.-]/.test(s[i - 1] ?? "")) {
+			const m = /^@(else\s+if|for|if|switch|case|slot|else|empty|default|let|input)(?![\w$-])/.exec(s.slice(i, i + 16));
+			if (m) {
+				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));
+					if (name) inputs.push(name[0]);
+					i = j;
+					continue;
+				}
+				if (kw === "let") {
+					const name = /^\s+([\w$]+)\s*=/.exec(s.slice(j, j + 64));
+					const semi = s.indexOf(";", j);
+					if (name && semi >= 0 && semi < stop) frames.at(-1).push(name[1]);
+					i = semi >= 0 && semi < stop ? semi + 1 : stop;
+					continue;
+				}
+				let header = "";
+				while (j < stop && /\s/.test(s[j])) j++;
+				if (s[j] === "(") {
+					const end = closeParen(s, j, stop);
+					if (end < 0) break;
+					header = s.slice(j + 1, end - 1);
+					j = end;
+				}
+				while (j < stop && /\s/.test(s[j])) j++;
+				if (s[j] === "{") {
+					frames.push(headerNames(kw, header));
+					i = j + 1;
+					continue;
+				}
+				i = j;
+				continue;
+			}
+		}
+		if (c === "}" && frames.length > 1) frames.pop();
+		i++;
+	}
+	return [...inputs, ...frames.flat()];
+}
+function exprContext(segment, s, offset) {
+	const pipe = /\|\s*([A-Za-z_$][\w$]*)?$/.exec(segment);
+	if (pipe && !/\|\|\s*[\w$]*$/.test(segment)) return {
+		kind: "pipe",
+		prefix: pipe[1] ?? ""
+	};
+	if (/\??\.\s*[\w$]*$/.test(segment)) return { kind: "other" };
+	return {
+		kind: "expr",
+		prefix: /([A-Za-z_$][\w$]*)?$/.exec(segment)[1] ?? "",
+		scope: scopeAt(s, offset)
+	};
+}
+function cursorContext(s, offset) {
+	const before = s.slice(0, offset);
+	const open = before.lastIndexOf("{{");
+	if (open >= 0 && open > before.lastIndexOf("}}") && !before.startsWith("{{--", open)) return exprContext(before.slice(open + 2), s, offset);
+	const named = /@(layout|slot)\s*\(\s*['"]([^'"]*)$/.exec(before);
+	if (named) return {
+		kind: named[1] === "layout" ? "template-name" : "slot-name",
+		prefix: named[2]
+	};
+	const letExpr = /@let\s+[\w$]+\s*=\s*([^;\n]*)$/.exec(before);
+	if (letExpr) return exprContext(letExpr[1], s, offset);
+	const header = /@(?:else\s+if|if|for|switch|case)\s*\(([^]*)$/.exec(before);
+	if (header && closeParen(before, before.length - header[1].length - 1, before.length) < 0) return exprContext(header[1], s, offset);
+	const tag = /<([A-Za-z][\w:.-]*)((?:[^<>"']|"[^"]*"|'[^']*')*?)(["'][^"']*)?$/.exec(before);
+	if (tag && !before.endsWith(">")) {
+		const [, name, attrs = "", openValue] = tag;
+		if (openValue !== void 0) {
+			if (/\[[^\]]+\]\s*=\s*$/.test(attrs)) return exprContext(openValue.slice(1), s, offset);
+			return { kind: "other" };
+		}
+		if (!attrs) return {
+			kind: "tag",
+			prefix: name
+		};
+		if (name.includes("-")) {
+			const attr = /\s\[?([\w-]*)$/.exec(attrs);
+			if (attr) return {
+				kind: "attr",
+				tag: name.toLowerCase(),
+				prefix: attr[1]
+			};
+		}
+		return { kind: "other" };
+	}
+	const kw = /(?<![\w@.-])@([A-Za-z]*)$/.exec(before);
+	if (kw) return {
+		kind: "keyword",
+		prefix: kw[1]
+	};
+	return { kind: "other" };
+}
+/** The name under the cursor (pipes, tags, template names) and its range. */
+function wordAt(s, offset) {
+	let start = offset;
+	let end = offset;
+	while (start > 0 && /[\w$/-]/.test(s[start - 1])) start--;
+	while (end < s.length && /[\w$/-]/.test(s[end])) end++;
+	return {
+		word: s.slice(start, end),
+		start,
+		end
+	};
+}
+//#endregion
+//#region src/plugin/completion.ts
+const SNIPPET = 2;
+const KEYWORD = 14;
+const FUNCTION = 3;
+const CLASS = 7;
+const PROPERTY = 10;
+const FILE = 17;
+const VARIABLE = 6;
+const KEYWORDS = {
+	if: "if (${1:condition}) {\n	$0\n}",
+	"else if": "else if (${1:condition}) {\n	$0\n}",
+	else: "else {\n	$0\n}",
+	for: "for (${1:item} of ${2:items}) {\n	$0\n}",
+	empty: "empty {\n	$0\n}",
+	switch: "switch (${1:value}) {\n	@case (${2:match}) {\n		$0\n	}\n}",
+	case: "case (${1:match}) {\n	$0\n}",
+	default: "default {\n	$0\n}",
+	let: "let ${1:name} = $2;",
+	input: "input ${1:name}",
+	layout: "layout('$1')",
+	slot: "slot('${1:name}') {\n	$0\n}",
+	assets: "assets('$1')",
+	verbatim: "verbatim {\n	$0\n}"
+};
+/** The template a component tag names, if any. */
+function componentOf(ws, tag) {
+	const dir = ws.componentsDir();
+	return ws.names().find((n) => n.startsWith(`${dir}/`) && ws.view.componentTag(n, dir) === tag);
+}
+/** Slot names the layouts above `name` declare, nearest first. */
+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)) {
+		seen.add(layout);
+		const ast = ws.astOf(layout);
+		if (!ast) break;
+		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);
+			stack.push(n.fallback);
+		} else if (n.k === "element") stack.push(n.children);
+		else if (n.k === "if") for (const b of n.branches) stack.push(b.body);
+		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];
+}
+function completions(ws, uri, text, offset) {
+	const c = cursorContext(text, offset);
+	switch (c.kind) {
+		case "keyword": return Object.entries(KEYWORDS).map(([label, insertText]) => ({
+			label,
+			kind: KEYWORD,
+			insertText,
+			insertTextFormat: SNIPPET
+		}));
+		case "pipe": return ws.pipeNames().map((label) => ({
+			label,
+			kind: FUNCTION
+		}));
+		case "tag": {
+			const dir = ws.componentsDir();
+			return ws.names().filter((n) => n.startsWith(`${dir}/`)).map((n) => {
+				const tag = ws.view.componentTag(n, dir);
+				const attrs = (ws.astOf(n)?.inputs ?? []).filter((i) => !i.default).map((i, k) => ` [${i.name}]="$${k + 1}"`).join("");
+				return {
+					label: tag,
+					kind: CLASS,
+					insertText: `${tag}${attrs} />`,
+					insertTextFormat: SNIPPET
+				};
+			});
+		}
+		case "attr": {
+			const name = componentOf(ws, c.tag);
+			if (!name) return [];
+			return [
+				...(ws.astOf(name)?.inputs ?? []).flatMap((i) => [{
+					label: `[${i.name}]`,
+					kind: PROPERTY,
+					insertText: `[${i.name}]="$1"`,
+					insertTextFormat: SNIPPET
+				}, {
+					label: i.name,
+					kind: PROPERTY,
+					insertText: `${i.name}="$1"`,
+					insertTextFormat: SNIPPET
+				}]),
+				{
+					label: "class",
+					kind: PROPERTY
+				},
+				{
+					label: "id",
+					kind: PROPERTY
+				}
+			];
+		}
+		case "template-name": {
+			const dir = ws.componentsDir();
+			return ws.names().filter((n) => !n.startsWith(`${dir}/`)).map((label) => ({
+				label,
+				kind: FILE
+			}));
+		}
+		case "slot-name": return layoutSlots(ws, ws.nameOf(uri)).map((label) => ({
+			label,
+			kind: PROPERTY
+		}));
+		case "expr": return [...new Set(c.scope)].map((label) => ({
+			label,
+			kind: VARIABLE
+		}));
+		default: return [];
+	}
+}
+//#endregion
+//#region src/plugin/hover.ts
+/** Worded as in the guide's pipe table. */
+const BUILTIN = {
+	uppercase: "`uppercase` — the text in upper case",
+	lowercase: "`lowercase` — the text in lower case",
+	titlecase: "`titlecase` — each word capitalised",
+	date: "`date:format:timeZone?` — `short`, `medium`, `long`, `full`, `shortDate`, … e.g. `date:'short'`",
+	number: "`number:digits` — `minInt.minFrac-maxFrac`, e.g. `number:'1.0-2'`",
+	currency: "`currency:code:digits?` — e.g. `currency:'KES'`",
+	percent: "`percent:digits?` — a ratio as a percentage",
+	slice: "`slice:start:end` — part of a list or string",
+	keys: "`keys` — an object’s keys",
+	entries: "`entries` — an object’s `[key, value]` pairs",
+	json: "`json` — the value as JSON",
+	url: "`url` — URL-encoded for a query string",
+	raw: "`raw` — the HTML unescaped; only for trusted markup"
+};
+function hover(ws, _uri, text, offset) {
+	const { word, start, end } = wordAt(text, offset);
+	if (!word) return null;
+	const c = cursorContext(text, end);
+	const md = (value) => ({
+		contents: {
+			kind: "markdown",
+			value
+		},
+		range: {
+			start: posOf(text, start),
+			end: posOf(text, end)
+		}
+	});
+	if (c.kind === "pipe") {
+		if (BUILTIN[word]) return md(BUILTIN[word]);
+		const decl = ws.pipeDeclaration(word);
+		return decl ? md(`\`\`\`ts\n${decl.signature}\n\`\`\``) : null;
+	}
+	if (c.kind === "tag") {
+		const name = componentOf(ws, word.toLowerCase());
+		const ast = name === void 0 ? void 0 : ws.astOf(name);
+		if (!ast) return null;
+		const lines = ast.inputs.map((i) => i.default ? `- \`${i.name}\` = \`${JSON.stringify(i.default.value)}\`` : `- \`${i.name}\` (required)`);
+		return md([`**<${word}>** — \`${name}.kick\``, ...lines].join("\n"));
+	}
+	return null;
+}
+function posOf(text, offset) {
+	const before = text.slice(0, offset).split("\n");
+	return {
+		line: before.length - 1,
+		character: before.at(-1).length
+	};
+}
+//#endregion
+//#region src/plugin/definition.ts
+const TOP = {
+	start: {
+		line: 0,
+		character: 0
+	},
+	end: {
+		line: 0,
+		character: 0
+	}
+};
+function definition(ws, _uri, text, offset) {
+	const { word, start, end } = wordAt(text, offset);
+	if (!word) return null;
+	const origin = {
+		start: posOf(text, start),
+		end: posOf(text, end)
+	};
+	const link = (targetUri, targetRange = TOP) => ({
+		originSelectionRange: origin,
+		targetUri,
+		targetRange,
+		targetSelectionRange: targetRange
+	});
+	const c = cursorContext(text, end);
+	if (c.kind === "tag") {
+		const name = componentOf(ws, word.toLowerCase());
+		return name === void 0 ? null : link(ws.uriOf(name));
+	}
+	if (c.kind === "template-name") return ws.astOf(word) ? link(ws.uriOf(word)) : null;
+	if (c.kind === "pipe") {
+		const decl = ws.pipeDeclaration(word);
+		if (!decl) return null;
+		const range = {
+			start: {
+				line: decl.line,
+				character: decl.column
+			},
+			end: {
+				line: decl.line,
+				character: decl.column + word.length
+			}
+		};
+		return link(URI.file(ws.pipesFile()).toString(), range);
+	}
+	return null;
+}
+//#endregion
+//#region src/plugin/diagnostics.ts
+/** The `.kick` file a root virtual-code document belongs to. */
+function sourceUri(context, uri) {
+	return context.decodeEmbeddedDocumentUri?.(URI.parse(uri))?.[0].toString() ?? uri;
+}
+function createDiagnosticsPlugin(ws) {
+	return {
+		name: "kick-diagnostics",
+		capabilities: { diagnosticProvider: {
+			interFileDependencies: true,
+			workspaceDiagnostics: false
+		} },
+		create(context) {
+			return { provideDiagnostics(document) {
+				if (document.languageId !== "kick") return void 0;
+				const uri = sourceUri(context, document.uri);
+				ws.sync(uri, document.getText());
+				return ws.diagnosticsFor(uri);
+			} };
+		}
+	};
+}
+//#endregion
+//#region src/plugin/format.ts
+/** One whole-document edit, or none on a parse error or when nothing changes. */
+function formatEdits(view, text, file, tabSize) {
+	const { output } = view.format(text, file, { indent: tabSize });
+	if (output === void 0 || output === text) return [];
+	return [{
+		range: {
+			start: {
+				line: 0,
+				character: 0
+			},
+			end: posOf(text, text.length)
+		},
+		newText: output
+	}];
+}
+//#endregion
+//#region src/plugin/index.ts
+function createKickServicePlugin(ws) {
+	const diagnostics = createDiagnosticsPlugin(ws);
+	return {
+		name: "kick",
+		capabilities: {
+			...diagnostics.capabilities,
+			completionProvider: { triggerCharacters: [
+				"@",
+				"|",
+				"<",
+				"[",
+				"'",
+				"\""
+			] },
+			hoverProvider: true,
+			definitionProvider: true,
+			documentFormattingProvider: true
+		},
+		create(context) {
+			/** The source file's uri and text, with the workspace synced to the buffer. */
+			const open = (document) => {
+				if (document.languageId !== "kick") return void 0;
+				const uri = sourceUri(context, document.uri);
+				const text = document.getText();
+				ws.sync(uri, text);
+				return {
+					uri,
+					text
+				};
+			};
+			return {
+				...diagnostics.create(context),
+				provideCompletionItems(document, position) {
+					const d = open(document);
+					if (!d) return void 0;
+					const items = completions(ws, d.uri, d.text, document.offsetAt(position));
+					return items.length ? {
+						isIncomplete: false,
+						items
+					} : void 0;
+				},
+				provideHover(document, position) {
+					const d = open(document);
+					return d ? hover(ws, d.uri, d.text, document.offsetAt(position)) ?? void 0 : void 0;
+				},
+				provideDefinition(document, position) {
+					const d = open(document);
+					const link = d && definition(ws, d.uri, d.text, document.offsetAt(position));
+					return link ? [link] : void 0;
+				},
+				provideDocumentFormattingEdits(document, _range, options) {
+					const d = open(document);
+					if (!d) return void 0;
+					return formatEdits(ws.view, d.text, `${ws.nameOf(d.uri) ?? "template"}.kick`, options.tabSize);
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/view-module.ts
+/**
+* Which `@forinda/kickjs-view` the server runs: the project's own, so the
+* editor parses, checks and formats exactly as the app's build does, or the
+* copy bundled with the server when the project has none (or one too old to
+* have what the editor calls).
+*/
+const BUNDLED_VERSION = "0.1.0";
+const REQUIRED = [
+	"parse",
+	"check",
+	"format",
+	"readPipeExports",
+	"templateName",
+	"componentTag",
+	"BUILTIN_PIPES"
+];
+let warned = false;
+/**
+* The project's `@forinda/kickjs-view` entry and version. Its exports map
+* only has `import`, which `require.resolve` can't see — so find the
+* package folder and read the entry from its exports.
+*/
+function findProjectView(root) {
+	for (let dir = root;; dir = dirname(dir)) {
+		const pkgDir = join(dir, "node_modules/@forinda/kickjs-view");
+		let pkg;
+		try {
+			pkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
+		} catch {
+			if (dir === dirname(dir)) return void 0;
+			continue;
+		}
+		const dot = typeof pkg.exports === "string" ? pkg.exports : pkg.exports?.["."];
+		const rel = typeof dot === "string" ? dot : dot?.node ?? dot?.import ?? dot?.default ?? pkg.main;
+		const entry = resolve(pkgDir, typeof rel === "string" ? rel : "index.js");
+		if (relative(pkgDir, entry).startsWith("..") || isAbsolute(relative(pkgDir, entry))) return void 0;
+		return {
+			entry,
+			version: pkg.version
+		};
+	}
+}
+async function loadViewModule(root, warn, trusted) {
+	if (!trusted) return {
+		view: bundled,
+		source: "bundled",
+		version: BUNDLED_VERSION
+	};
+	const found = findProjectView(root);
+	let reason = "the project has no @forinda/kickjs-view";
+	if (found) {
+		reason = `the project's @forinda/kickjs-view ${found.version}`;
+		try {
+			const mod = await import(pathToFileURL(found.entry).href);
+			const missing = REQUIRED.filter((k) => !(k in mod));
+			if (!missing.length) return {
+				view: mod,
+				source: "project",
+				version: found.version
+			};
+			reason += ` lacks ${missing.join(", ")}`;
+		} catch (err) {
+			reason += ` failed to load: ${err.message}`;
+		}
+	}
+	if (!warned) {
+		warned = true;
+		warn(`kick views: ${reason} — using the bundled ${BUNDLED_VERSION}`);
+	}
+	return {
+		view: bundled,
+		source: "bundled",
+		version: BUNDLED_VERSION
+	};
+}
+//#endregion
+//#region src/pipes.ts
+const DECL = /^export\s+(?:(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]*)?=\s*(?:\(([^)]*)\)|([A-Za-z_$][\w$]*)\s*=>)|function\s+([A-Za-z_$][\w$]*)\s*(?:<[^>]*>)?\s*\(([^)]*)\))/d;
+function pipeDeclarations(source) {
+	const out = /* @__PURE__ */ new Map();
+	source.split("\n").forEach((text, line) => {
+		const m = DECL.exec(text);
+		if (!m) return;
+		const group = m[1] === void 0 ? 4 : 1;
+		const name = m[group];
+		const params = (m[2] ?? m[3] ?? m[5] ?? "").replace(/\s+/g, " ").trim();
+		out.set(name, {
+			line,
+			column: m.indices[group][0],
+			signature: `${name}(${params})`
+		});
+	});
+	return out;
+}
+//#endregion
+//#region src/positions.ts
+const toPosition = (pos) => ({
+	line: pos.line - 1,
+	character: pos.column - 1
+});
+const toRange = (span) => ({
+	start: toPosition(span.start),
+	end: toPosition(span.end)
+});
+//#endregion
+//#region src/workspace.ts
+/**
+* The editor's view of an app's templates: every `.kick` file under the
+* views folder (an open buffer wins over the file on disk) and the pipe names
+* from `pipes.ts`. Diagnostics come from the same `parse` + `check` the
+* runtime uses, cached per template and invalidated along the graph of
+* which template uses which component or layout.
+*/
+var Workspace = class {
+	opts;
+	entries = /* @__PURE__ */ new Map();
+	cache = /* @__PURE__ */ new Map();
+	pipes = [];
+	pipeDecls = /* @__PURE__ */ new Map();
+	constructor(opts) {
+		this.opts = opts;
+	}
+	get view() {
+		return this.opts.view;
+	}
+	async load() {
+		await this.loadPipes();
+		for (const path of await this.opts.list(this.opts.viewsDir)) {
+			const name = this.nameOfPath(path);
+			if (name) this.update(name, { disk: await this.opts.read(path) });
+		}
+	}
+	nameOfPath(path) {
+		const rel = relative(this.opts.viewsDir, path).split(sep).join(posix.sep);
+		if (rel.startsWith("..") || !rel.endsWith(".kick")) return void 0;
+		return this.opts.view.templateName(rel.slice(0, -5));
+	}
+	nameOf(uri) {
+		return this.nameOfPath(URI.parse(uri).fsPath);
+	}
+	uriOf(name) {
+		return URI.file(`${this.opts.viewsDir}/${name}.kick`).toString();
+	}
+	componentsDir() {
+		return this.opts.componentsDir;
+	}
+	pathOf(name) {
+		return `${this.opts.viewsDir}/${name}.kick`;
+	}
+	names() {
+		return [...this.entries.keys()];
+	}
+	textOf(name) {
+		const e = this.entries.get(name);
+		return e?.buffer ?? e?.disk;
+	}
+	astOf(name) {
+		return this.entries.get(name)?.ast;
+	}
+	/** An editor buffer for `uri`; `undefined` drops it and the file on disk applies again. */
+	setBuffer(uri, text) {
+		const name = this.nameOf(uri);
+		if (!name) return;
+		const e = this.entries.get(name);
+		if (text === void 0 && e?.disk === void 0) {
+			this.remove(name);
+			return;
+		}
+		this.update(name, {
+			disk: e?.disk,
+			buffer: text
+		});
+	}
+	/** `setBuffer`, skipped when the buffer is already `text`. */
+	sync(uri, text) {
+		if (this.textOf(this.nameOf(uri) ?? "") !== text) this.setBuffer(uri, text);
+	}
+	async fileChanged(path) {
+		if (path === this.opts.pipesFile) {
+			await this.loadPipes();
+			this.cache.clear();
+			return;
+		}
+		const name = this.nameOfPath(path);
+		if (name) this.update(name, {
+			disk: await this.opts.read(path),
+			buffer: this.entries.get(name)?.buffer
+		});
+	}
+	async fileDeleted(path) {
+		if (path === this.opts.pipesFile) {
+			this.pipes = [];
+			this.pipeDecls = /* @__PURE__ */ new Map();
+			this.cache.clear();
+			return;
+		}
+		const name = this.nameOfPath(path);
+		if (!name) return;
+		const buffer = this.entries.get(name)?.buffer;
+		if (buffer !== void 0) this.update(name, { buffer });
+		else this.remove(name);
+	}
+	async loadPipes() {
+		const source = await this.opts.read(this.opts.pipesFile);
+		this.pipes = source === void 0 ? [] : this.opts.view.readPipeExports(source, this.opts.pipesFile).names;
+		this.pipeDecls = source === void 0 ? /* @__PURE__ */ new Map() : pipeDeclarations(source);
+	}
+	update(name, src) {
+		const text = src.buffer ?? src.disk ?? "";
+		const parsed = this.opts.view.parse(text, `${name}.kick`);
+		const tags = /* @__PURE__ */ new Set();
+		const layouts = /* @__PURE__ */ new Set();
+		if (typeof parsed.ast.layout === "string") layouts.add(parsed.ast.layout);
+		const stack = [parsed.ast.body];
+		while (stack.length) for (const n of stack.pop()) if (n.k === "element") {
+			if (!n.foreign && n.tag.includes("-")) tags.add(n.tag.toLowerCase());
+			stack.push(n.children);
+		} else if (n.k === "if") for (const b of n.branches) stack.push(b.body);
+		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-outlet") stack.push(n.fallback);
+		else if (n.k === "slot-fill") stack.push(n.body);
+		const isNew = !this.entries.has(name);
+		this.entries.set(name, {
+			...src,
+			ast: parsed.ast,
+			parseDiagnostics: parsed.diagnostics,
+			tags,
+			layouts
+		});
+		this.invalidate(name, isNew);
+	}
+	remove(name) {
+		this.entries.delete(name);
+		this.invalidate(name, true);
+	}
+	/** Drop cached diagnostics for `name` and every template that uses it, transitively. */
+	invalidate(name, membershipChanged) {
+		const todo = [name];
+		const seen = /* @__PURE__ */ new Set();
+		while (todo.length) {
+			const n = todo.pop();
+			if (seen.has(n)) continue;
+			seen.add(n);
+			this.cache.delete(n);
+			for (const d of this.dependentsOf(n)) todo.push(d);
+		}
+		if (membershipChanged && name.startsWith(`${this.opts.componentsDir}/`)) {
+			const tag = this.opts.view.componentTag(name, this.opts.componentsDir);
+			for (const [n, e] of this.entries) if (e.tags.has(tag)) this.cache.delete(n);
+		}
+	}
+	/** Templates that use `name` as a component or a layout — a layout even after it's gone. */
+	dependentsOf(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) {
+			if (n === name) continue;
+			if (tag && e.tags.has(tag) && this.entries.has(name) || e.layouts.has(name)) out.add(n);
+		}
+		return out;
+	}
+	pipeNames() {
+		return [...this.opts.view.BUILTIN_PIPES, ...this.pipes];
+	}
+	/** Where an app pipe is declared in `pipes.ts`, and its parameters. */
+	pipeDeclaration(name) {
+		return this.pipeDecls.get(name);
+	}
+	pipesFile() {
+		return this.opts.pipesFile;
+	}
+	project() {
+		return {
+			templates: new Map([...this.entries].map(([n, e]) => [n, e.ast])),
+			pipes: new Set(this.pipeNames()),
+			componentsDir: this.opts.componentsDir
+		};
+	}
+	/** Parse errors, else everything `check` reports — as LSP diagnostics. */
+	diagnosticsFor(uri) {
+		const name = this.nameOf(uri);
+		const e = name === void 0 ? void 0 : this.entries.get(name);
+		if (!name || !e) return [];
+		const cached = this.cache.get(name);
+		if (cached) return cached;
+		const out = (e.parseDiagnostics.some((d) => d.severity === "error") ? e.parseDiagnostics : [...e.parseDiagnostics, ...this.opts.view.check(name, this.project()).diagnostics]).map((d) => ({
+			range: toRange(d.span),
+			severity: d.severity === "error" ? 1 : 2,
+			source: "kick",
+			message: d.message
+		}));
+		this.cache.set(name, out);
+		return out;
+	}
+};
+//#endregion
+//#region src/server.ts
+/**
+* The language server: Volar's server with the `.kick` language plugin and
+* the HTML, CSS, Emmet and kick service plugins, over the project's own
+* `@forinda/kickjs-view` when it has one.
+*/
+/** Every `.kick` file under `dir`; none when it doesn't exist. */
+async function listKick(dir) {
+	try {
+		return (await readdir(dir, { recursive: true })).filter((n) => n.endsWith(".kick")).map((n) => join(dir, n));
+	} catch {
+		return [];
+	}
+}
+/** What the server watches: every template, and the pipes file wherever it's configured. */
+function watchPatterns(root, pipesFile) {
+	const patterns = ["**/*.kick", "**/pipes.{ts,js}"];
+	if (!/^pipes\.(ts|js)$/.test(basename(pipesFile))) patterns.push(relative(root, pipesFile).split(sep).join("/"));
+	return patterns;
+}
+function startServer() {
+	const connection = createConnection();
+	const server = createServer(connection);
+	let ws;
+	let watched = [];
+	connection.listen();
+	connection.onInitialize(async (params) => {
+		const folder = params.workspaceFolders?.[0]?.uri ?? params.rootUri;
+		const root = folder ? URI.parse(folder).fsPath : process.cwd();
+		const opts = params.initializationOptions ?? {};
+		const at = (p) => isAbsolute(p) ? p : resolve(root, p);
+		const viewsDir = at(opts.viewsDir ?? "src/views");
+		const hasViews = existsSync(viewsDir);
+		const { view } = await loadViewModule(root, (m) => hasViews && connection.console.warn(m), opts.trusted === true);
+		const pipesFile = at(opts.pipesFile ?? join(viewsDir, "pipes.ts"));
+		watched = watchPatterns(root, pipesFile);
+		ws = new Workspace({
+			root,
+			viewsDir,
+			componentsDir: opts.componentsDir ?? "components",
+			pipesFile,
+			view,
+			read: (p) => readFile(p, "utf8").catch(() => void 0),
+			list: listKick
+		});
+		await ws.load();
+		return server.initialize(params, createSimpleProject([kickLanguagePlugin]), [
+			create$2(),
+			create(),
+			create$1(),
+			createKickServicePlugin(ws)
+		]);
+	});
+	connection.onInitialized(() => {
+		server.initialized();
+		server.fileWatcher.watchFiles(watched);
+	});
+	server.fileWatcher.onDidChangeWatchedFiles(async ({ changes }) => {
+		if (!ws) return;
+		for (const c of changes) {
+			const path = URI.parse(c.uri).fsPath;
+			if (c.type === 3) await ws.fileDeleted(path);
+			else await ws.fileChanged(path);
+		}
+		await server.languageFeatures.requestRefresh(false);
+	});
+	server.documents.onDidClose(({ document }) => ws?.setBuffer(document.uri, void 0));
+	connection.onRequest("kick/templateNames", () => {
+		if (!ws) return [];
+		const dir = `${ws.componentsDir()}/`;
+		return ws.names().filter((n) => !n.startsWith(dir));
+	});
+	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-3edMz3HM.js.map