@askdkc/dsh-lsp-server 0.1.0

package/lib/provider.js

@@ -0,0 +1,1164 @@
+import { WebstackLspError } from "./errors-DtyWAUi0.js";
+import { SERVER_IDS, createWebstackLspService, initializationOptions, resolveConfig, resolveLaunch, serverConfiguration } from "./launch-ByUvgkVv.js";
+import { mergeCompletions, mergeDiagnostics } from "./completion-B7NPVCEN.js";
+import { LspProviderId } from "@deepseek-ai/dsh-lsp";
+import { TextDecoder } from "node:util";
+
+//#region src/runtime/cancellation.ts
+function abortError() {
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	return error;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw abortError();
+}
+function onAbort(signal, callback) {
+	if (!signal) return () => {};
+	if (signal.aborted) {
+		callback();
+		return () => {};
+	}
+	signal.addEventListener("abort", callback, { once: true });
+	return () => signal.removeEventListener("abort", callback);
+}
+async function withAbort(promise, signal) {
+	throwIfAborted(signal);
+	if (!signal) return promise;
+	return new Promise((resolve, reject) => {
+		const remove = onAbort(signal, () => reject(abortError()));
+		promise.then((value) => {
+			remove();
+			resolve(value);
+		}, (error) => {
+			remove();
+			reject(error);
+		});
+	});
+}
+
+//#endregion
+//#region src/host/dsh.ts
+async function readSource(fs, workspaceRoot, filePath, maxBytes, signal) {
+	if (!workspaceRoot?.trim() || !filePath?.trim()) throw new WebstackLspError("LSP_WORKSPACE_REQUIRED", "workspaceRoot and filePath are required");
+	throwIfAborted(signal);
+	const options = signal ? { signal } : {};
+	const root = await fs.resolve(workspaceRoot, options);
+	if ((await fs.stat(root, signal))?.type !== "directory") throw new Error("workspace root is not a directory");
+	const workspace = fs.processPath(root);
+	const target = await fs.resolve(filePath, {
+		cwd: workspace,
+		...options
+	});
+	if (!fs.contains(root, target)) throw new Error("source is outside workspace");
+	if ((await fs.stat(target, signal))?.type !== "file") throw new Error("source is not a regular file");
+	let text = "", bytes = 0;
+	for await (const chunk of await fs.streamText(target, signal)) {
+		throwIfAborted(signal);
+		bytes += Buffer.byteLength(chunk);
+		if (bytes > maxBytes) throw new Error("source exceeds document limit");
+		text += chunk;
+	}
+	throwIfAborted(signal);
+	return {
+		workspace,
+		workspaceUri: fs.fileUrl(root),
+		key: root.targetKey,
+		uri: fs.fileUrl(target),
+		text
+	};
+}
+
+//#endregion
+//#region src/routing/classifier.ts
+const CLASSIFIERS = [
+	{
+		suffix: ".blade.php",
+		kind: "blade"
+	},
+	{
+		suffix: ".typescriptreact",
+		kind: "typescriptreact"
+	},
+	{
+		suffix: ".javascriptreact",
+		kind: "javascriptreact"
+	},
+	{
+		suffix: ".tsx",
+		kind: "typescriptreact"
+	},
+	{
+		suffix: ".jsx",
+		kind: "javascriptreact"
+	},
+	{
+		suffix: ".mts",
+		kind: "typescript"
+	},
+	{
+		suffix: ".cts",
+		kind: "typescript"
+	},
+	{
+		suffix: ".mjs",
+		kind: "javascript"
+	},
+	{
+		suffix: ".cjs",
+		kind: "javascript"
+	},
+	{
+		suffix: ".svelte",
+		kind: "svelte"
+	},
+	{
+		suffix: ".html",
+		kind: "html"
+	},
+	{
+		suffix: ".htm",
+		kind: "html"
+	},
+	{
+		suffix: ".php",
+		kind: "php"
+	},
+	{
+		suffix: ".ts",
+		kind: "typescript"
+	},
+	{
+		suffix: ".js",
+		kind: "javascript"
+	},
+	{
+		suffix: ".css",
+		kind: "css"
+	},
+	{
+		suffix: ".pcss",
+		kind: "css"
+	}
+];
+function classifyFile(filePath, bladeSuffixes = [".blade.php"]) {
+	const normalizedPath = filePath.replaceAll("\\", "/");
+	const basename = normalizedPath.slice(normalizedPath.lastIndexOf("/") + 1).toLowerCase();
+	if (!basename || basename === "." || basename === ".." || basename.startsWith(".")) return void 0;
+	const customBlade = bladeSuffixes.map((suffix) => suffix.toLowerCase()).sort((left, right) => right.length - left.length);
+	const match = [...customBlade.map((suffix) => ({
+		suffix,
+		kind: "blade"
+	})), ...CLASSIFIERS.filter((item) => !customBlade.includes(item.suffix))].find((item) => basename.endsWith(item.suffix));
+	if (!match) return void 0;
+	return {
+		path: normalizedPath,
+		basename,
+		suffix: match.suffix,
+		kind: match.kind
+	};
+}
+
+//#endregion
+//#region src/routing/route-table.ts
+const ROUTES = {
+	blade: {
+		primary: {
+			server: "phpantom",
+			languageId: "blade"
+		},
+		auxiliary: {
+			server: "tailwind",
+			languageId: "html"
+		}
+	},
+	php: { primary: {
+		server: "phpantom",
+		languageId: "php"
+	} },
+	typescript: {
+		primary: {
+			server: "typescript",
+			languageId: "typescript"
+		},
+		auxiliary: {
+			server: "tailwind",
+			languageId: "typescript"
+		}
+	},
+	typescriptreact: {
+		primary: {
+			server: "typescript",
+			languageId: "typescriptreact"
+		},
+		auxiliary: {
+			server: "tailwind",
+			languageId: "typescriptreact"
+		}
+	},
+	javascript: {
+		primary: {
+			server: "typescript",
+			languageId: "javascript"
+		},
+		auxiliary: {
+			server: "tailwind",
+			languageId: "javascript"
+		}
+	},
+	javascriptreact: {
+		primary: {
+			server: "typescript",
+			languageId: "javascriptreact"
+		},
+		auxiliary: {
+			server: "tailwind",
+			languageId: "javascriptreact"
+		}
+	},
+	svelte: {
+		primary: {
+			server: "svelte",
+			languageId: "svelte"
+		},
+		auxiliary: {
+			server: "tailwind",
+			languageId: "svelte"
+		}
+	},
+	html: {
+		primary: {
+			server: "html",
+			languageId: "html"
+		},
+		auxiliary: {
+			server: "tailwind",
+			languageId: "html"
+		}
+	},
+	css: {
+		primary: {
+			server: "css",
+			languageId: "css"
+		},
+		auxiliary: {
+			server: "tailwind",
+			languageId: "css"
+		}
+	}
+};
+function routeFor(file) {
+	const route = ROUTES[file.kind];
+	return {
+		primary: { ...route.primary },
+		...route.auxiliary ? { auxiliary: { ...route.auxiliary } } : {}
+	};
+}
+
+//#endregion
+//#region src/routing/tailwind-candidate.ts
+const DEFAULT_PATTERNS = [
+	/\bclass\s*=\s*["'][^"']*$/i,
+	/\bclassName\s*=\s*["'][^"']*$/i,
+	/\bclass:list\s*=\s*["'][^"']*$/i,
+	/@apply\s+[\w-]*$/i,
+	/\b(?:clsx|cva)\s*\([^)]*["'][^"']*$/i
+];
+function hasTailwindCandidate(source, line, classRegex = [], character, classAttributes = [
+	"class",
+	"className",
+	"class:list"
+]) {
+	const lines = source.split(/\r?\n/);
+	const context = [...lines.slice(Math.max(0, line - 2), line), (lines[line] ?? "").slice(0, character)].join("\n");
+	if (classAttributes.some((attribute) => {
+		const index = context.lastIndexOf(attribute + "=");
+		return index >= 0 && /^[\"'][^\"']*$/.test(context.slice(index + attribute.length + 1).trimStart());
+	})) return true;
+	const configured = classRegex.flatMap((item) => Array.isArray(item) ? item : [item]).map((pattern) => new RegExp(pattern));
+	return [...DEFAULT_PATTERNS, ...configured].some((pattern) => pattern.test(context));
+}
+
+//#endregion
+//#region src/protocol/initialize.ts
+async function initializeServer(connection, params, signal) {
+	throwIfAborted(signal);
+	const value = await connection.request("initialize", params, signal);
+	if (!isInitializeResult(value)) throw new Error("malformed initialize response");
+	await connection.notify("initialized", {});
+	return value;
+}
+function isInitializeResult(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.capabilities === "object" && value.capabilities !== null;
+}
+
+//#endregion
+//#region src/runtime/framing.ts
+var JsonRpcFrameError = class extends Error {
+	code = "LSP_MALFORMED_RESPONSE";
+	constructor(message) {
+		super(message);
+		this.name = "JsonRpcFrameError";
+	}
+};
+var ContentLengthDecoder = class {
+	buffer = Buffer.alloc(0);
+	decoder = new TextDecoder("utf-8", { fatal: true });
+	constructor(maxMessageBytes) {
+		this.maxMessageBytes = maxMessageBytes;
+		if (!Number.isSafeInteger(maxMessageBytes) || maxMessageBytes <= 0) throw new RangeError("maxMessageBytes must be positive");
+	}
+	feed(chunk) {
+		this.buffer = Buffer.concat([this.buffer, Buffer.from(chunk)]);
+		const messages = [];
+		while (true) {
+			const headerEnd = this.buffer.indexOf(Buffer.from("\r\n\r\n"));
+			if (headerEnd < 0) {
+				if (this.buffer.length > 8192) throw new JsonRpcFrameError("header exceeds limit");
+				break;
+			}
+			const header = this.buffer.subarray(0, headerEnd).toString("ascii");
+			const length = this.parseLength(header);
+			const bodyStart = headerEnd + 4;
+			if (length > this.maxMessageBytes) throw new JsonRpcFrameError("message exceeds configured limit");
+			if (this.buffer.length < bodyStart + length) break;
+			const body = this.buffer.subarray(bodyStart, bodyStart + length);
+			this.buffer = this.buffer.subarray(bodyStart + length);
+			let text;
+			try {
+				text = this.decoder.decode(body);
+			} catch {
+				throw new JsonRpcFrameError("message is not valid UTF-8");
+			}
+			try {
+				messages.push(JSON.parse(text));
+			} catch {
+				throw new JsonRpcFrameError("message body is not valid JSON");
+			}
+		}
+		return messages;
+	}
+	end() {
+		if (this.buffer.length > 0) throw new JsonRpcFrameError("incomplete JSON-RPC frame");
+	}
+	parseLength(header) {
+		const lines = header.split("\r\n");
+		let length;
+		for (const line of lines) {
+			const separator = line.indexOf(":");
+			if (separator < 1) throw new JsonRpcFrameError("malformed header");
+			const key = line.slice(0, separator).toLowerCase();
+			const value = line.slice(separator + 1).trim();
+			if (key === "content-length") {
+				if (length !== void 0 || !/^\d+$/.test(value)) throw new JsonRpcFrameError("invalid Content-Length");
+				length = Number(value);
+			}
+		}
+		if (length === void 0 || !Number.isSafeInteger(length)) throw new JsonRpcFrameError("Content-Length is required");
+		return length;
+	}
+};
+function encodeJsonRpc(message) {
+	const body = Buffer.from(JSON.stringify(message), "utf8");
+	return Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "ascii"), body]);
+}
+
+//#endregion
+//#region src/runtime/connection.ts
+var JsonRpcConnection = class {
+	decoder;
+	pending = /* @__PURE__ */ new Map();
+	notificationListeners = /* @__PURE__ */ new Set();
+	nextId = 1;
+	closed = false;
+	requestHandler;
+	constructor(input, output, options) {
+		this.input = input;
+		this.output = output;
+		this.decoder = new ContentLengthDecoder(options.maxMessageBytes);
+		this.requestHandler = options.onServerRequest ?? (() => null);
+		if (options.onNotification) this.notificationListeners.add(options.onNotification);
+		input.on("data", (chunk) => this.receive(chunk));
+		input.once("end", () => this.close(/* @__PURE__ */ new Error("LSP process closed stdout")));
+		input.once("error", (error) => this.close(error));
+		output.on("error", (error) => this.close(error));
+	}
+	get isOpen() {
+		return !this.closed;
+	}
+	onNotification(listener) {
+		this.notificationListeners.add(listener);
+		return () => this.notificationListeners.delete(listener);
+	}
+	setRequestHandler(handler) {
+		this.requestHandler = handler;
+	}
+	async request(method, params, signal) {
+		throwIfAborted(signal);
+		if (this.closed) throw new Error("connection is closed");
+		const id = this.nextId++;
+		const promise = new Promise((resolve, reject) => this.pending.set(id, {
+			resolve,
+			reject,
+			method
+		}));
+		promise.catch(() => {});
+		const remove = onAbort(signal, () => {
+			this.notify("$/cancelRequest", { id }).catch(() => {});
+			this.pending.get(id)?.reject(abortError());
+			this.pending.delete(id);
+		});
+		try {
+			this.write({
+				jsonrpc: "2.0",
+				id,
+				method,
+				...params === void 0 ? {} : { params }
+			}).catch((error) => this.close(error));
+			return await promise;
+		} finally {
+			remove();
+			this.pending.delete(id);
+		}
+	}
+	async notify(method, params) {
+		if (this.closed) throw new Error("connection is closed");
+		await this.write({
+			jsonrpc: "2.0",
+			method,
+			...params === void 0 ? {} : { params }
+		});
+	}
+	close(reason = /* @__PURE__ */ new Error("connection closed")) {
+		if (this.closed) return;
+		this.closed = true;
+		for (const pending of this.pending.values()) pending.reject(reason);
+		this.pending.clear();
+	}
+	receive(chunk) {
+		if (this.closed) return;
+		let messages;
+		try {
+			messages = this.decoder.feed(chunk);
+		} catch (error) {
+			this.close(error instanceof Error ? error : new JsonRpcFrameError("invalid frame"));
+			return;
+		}
+		for (const message of messages) this.dispatch(message);
+	}
+	dispatch(value) {
+		if (!isRecord$4(value) || value.jsonrpc !== "2.0") return this.close(new JsonRpcFrameError("invalid JSON-RPC message"));
+		if ("method" in value && typeof value.method === "string") {
+			if ("id" in value) {
+				const request = value;
+				Promise.resolve().then(() => this.requestHandler(request.method, request.params)).then((result) => this.write({
+					jsonrpc: "2.0",
+					id: request.id,
+					result
+				}), (error) => this.write({
+					jsonrpc: "2.0",
+					id: request.id,
+					error: {
+						code: -32603,
+						message: error instanceof Error ? error.message : "server request failed"
+					}
+				})).catch(() => {});
+			} else for (const listener of this.notificationListeners) listener(value);
+			return;
+		}
+		if ("id" in value) {
+			const response = value;
+			const pending = this.pending.get(response.id);
+			if (!pending) return;
+			if (response.error) pending.reject(/* @__PURE__ */ new Error(`${response.error.code}: ${response.error.message}`));
+			else pending.resolve(response.result);
+			this.pending.delete(response.id);
+		}
+	}
+	write(message) {
+		return new Promise((resolve, reject) => {
+			this.output.write(encodeJsonRpc(message), (error) => error ? reject(error) : resolve());
+		});
+	}
+};
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/runtime/server-session.ts
+var ServerSession = class {
+	state = "NEW";
+	capabilities = {};
+	child;
+	connection;
+	stopping;
+	lifetime = new AbortController();
+	constructor(options) {
+		this.options = options;
+	}
+	async start(signal) {
+		throwIfAborted(signal);
+		this.state = "STARTING";
+		try {
+			const child = this.options.spawn();
+			this.child = child;
+			child.done.catch(() => {});
+			if (!child.stdout || !child.stdin) throw new Error("server stdio is unavailable");
+			const connection = new JsonRpcConnection(child.stdout, child.stdin, {
+				maxMessageBytes: this.options.maxMessageBytes,
+				onServerRequest: (method, params) => this.answer(method, params)
+			});
+			this.connection = connection;
+			child.done.then(() => connection.close(/* @__PURE__ */ new Error("LSP process exited")), (error) => connection.close(error instanceof Error ? error : /* @__PURE__ */ new Error("LSP spawn failed"))).then(() => {
+				if (this.state !== "STOPPING" && this.state !== "STOPPED") this.state = "FAILED";
+			});
+			const result = await initializeServer(connection, this.options.initialize, this.signal(signal));
+			if (result.capabilities.positionEncoding && result.capabilities.positionEncoding !== "utf-16") throw new Error("server requires unsupported position encoding");
+			const sync = result.capabilities.textDocumentSync;
+			if (sync === void 0 || sync === 0 || typeof sync === "object" && sync !== null && !sync.openClose) throw new Error("server does not support document open/close");
+			this.capabilities = result.capabilities;
+			await connection.notify("workspace/didChangeConfiguration", { settings: this.options.configuration });
+			throwIfAborted(this.signal(signal));
+			this.state = "READY";
+			return result;
+		} catch (error) {
+			this.state = "FAILED";
+			await this.stop();
+			throw error;
+		}
+	}
+	get usable() {
+		return this.state === "READY" && !!this.connection?.isOpen;
+	}
+	isUsable() {
+		return this.usable;
+	}
+	async run(task, signal) {
+		if (!this.usable || !this.connection) throw new Error("session is not ready");
+		try {
+			return await withAbort(task(this.connection), this.signal(signal));
+		} catch (error) {
+			if (signal?.aborted || !this.connection.isOpen) await this.stop();
+			throw error;
+		}
+	}
+	stop() {
+		return this.stopping ??= this.teardown();
+	}
+	async teardown() {
+		this.state = "STOPPING";
+		this.lifetime.abort();
+		const child = this.child, connection = this.connection;
+		const timeout = AbortSignal.timeout(this.options.shutdown.shutdownMs);
+		if (connection?.isOpen) try {
+			await connection.request("shutdown", null, timeout);
+			await connection.notify("exit");
+		} catch {}
+		connection?.close(/* @__PURE__ */ new Error("session stopped"));
+		if (child) {
+			child.terminate();
+			if (!await child.waitForExit(AbortSignal.timeout(this.options.shutdown.killGraceMs + 1e3))) throw new Error("language server process tree did not exit within the cleanup deadline");
+		}
+		this.state = "STOPPED";
+	}
+	signal(signal) {
+		return signal ? AbortSignal.any([signal, this.lifetime.signal]) : this.lifetime.signal;
+	}
+	answer(method, params) {
+		if (method === "workspace/applyEdit") return {
+			applied: false,
+			failureReason: "read-only provider"
+		};
+		if (method === "workspace/workspaceFolders") return this.options.initialize.workspaceFolders ?? [];
+		if (method === "workspace/configuration") return (params?.items ?? []).map((item) => {
+			let value = this.options.configuration;
+			for (const key of item.section?.split(".") ?? []) value = typeof value === "object" && value !== null ? value[key] : void 0;
+			return value ?? null;
+		});
+		return null;
+	}
+};
+
+//#endregion
+//#region src/runtime/server-pool.ts
+var ServerPool = class {
+	sessions = /* @__PURE__ */ new Map();
+	creation = /* @__PURE__ */ new Map();
+	queues = /* @__PURE__ */ new Map();
+	disposing = false;
+	constructor(factory) {
+		this.factory = factory;
+	}
+	async getOrCreate(serverId, workspace, signal) {
+		throwIfAborted(signal);
+		if (this.disposing) throw new Error("server pool is disposing");
+		const key = keyOf(serverId, workspace);
+		const existing = this.sessions.get(key);
+		if (existing?.isUsable()) return existing;
+		const pending = this.creation.get(key);
+		if (pending) return withAbort(pending, signal);
+		const creation = this.create(key, serverId, workspace, existing, signal);
+		this.creation.set(key, creation);
+		try {
+			return await creation;
+		} finally {
+			if (this.creation.get(key) === creation) this.creation.delete(key);
+		}
+	}
+	run(serverId, workspace, task, signal) {
+		return this.serialize(keyOf(serverId, workspace), async () => task(await this.getOrCreate(serverId, workspace, signal)), signal);
+	}
+	runWithRetry(serverId, workspace, task, signal) {
+		return this.serialize(keyOf(serverId, workspace), async () => {
+			for (let attempt = 0;; attempt++) {
+				const session = await this.getOrCreate(serverId, workspace, signal);
+				try {
+					return await task(session);
+				} catch (error) {
+					throwIfAborted(signal);
+					if (attempt > 0 || session.isUsable()) throw error;
+					if (this.sessions.get(keyOf(serverId, workspace)) === session) await this.evict(serverId, workspace);
+				}
+			}
+		}, signal);
+	}
+	async evict(serverId, workspace) {
+		const key = keyOf(serverId, workspace);
+		const session = this.sessions.get(key);
+		this.sessions.delete(key);
+		if (session) await session.stop();
+	}
+	async disposeAll() {
+		this.disposing = true;
+		const results = await Promise.allSettled([...this.sessions.values()].map((session) => session.stop()));
+		this.sessions.clear();
+		await Promise.all([...this.creation.values()].map((creation) => creation.then((session) => session.stop(), () => {})));
+		this.creation.clear();
+		const failures = results.filter((result) => result.status === "rejected");
+		if (failures.length) throw new AggregateError(failures.map((result) => result.reason), "language server cleanup failed");
+	}
+	get size() {
+		return this.sessions.size;
+	}
+	async serialize(key, task, signal) {
+		const previous = this.queues.get(key) ?? Promise.resolve();
+		let release;
+		const current = new Promise((resolve) => {
+			release = resolve;
+		});
+		this.queues.set(key, current);
+		try {
+			await withAbort(previous, signal);
+			throwIfAborted(signal);
+			return await task();
+		} finally {
+			previous.then(release, release);
+			current.then(() => {
+				if (this.queues.get(key) === current) this.queues.delete(key);
+			});
+		}
+	}
+	async create(key, serverId, workspace, previous, signal) {
+		if (previous) {
+			this.sessions.delete(key);
+			await previous.stop();
+		}
+		throwIfAborted(signal);
+		const session = await this.factory(serverId, workspace, signal);
+		try {
+			await session.start(signal);
+		} catch (error) {
+			await session.stop();
+			throw error;
+		}
+		if (this.disposing) {
+			await session.stop();
+			throw new Error("server pool is disposing");
+		}
+		this.sessions.set(key, session);
+		return session;
+	}
+};
+function keyOf(serverId, workspace) {
+	return `${serverId}\u0000${workspace}`;
+}
+
+//#endregion
+//#region src/protocol/capabilities.ts
+function supportsOperation(capabilities, operation) {
+	if (operation === "goToDefinition") return capabilities.definitionProvider === true || isProvider(capabilities.definitionProvider);
+	if (operation === "findReferences") return capabilities.referencesProvider === true || isProvider(capabilities.referencesProvider);
+	if (operation === "goToImplementation") return capabilities.implementationProvider === true || isProvider(capabilities.implementationProvider);
+	return capabilities.hoverProvider === true || isProvider(capabilities.hoverProvider);
+}
+function isProvider(value) {
+	return typeof value === "object" && value !== null || value === true;
+}
+
+//#endregion
+//#region src/protocol/normalize-hover.ts
+function normalizeHover(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const contents = normalizeContents(record.contents);
+	if (contents === void 0) return void 0;
+	return {
+		contents,
+		...isRange$2(record.range) ? { range: record.range } : {}
+	};
+}
+function normalizeContents(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		const parts = value.map((item) => typeof item === "string" ? item : isRecord$3(item) && typeof item.value === "string" ? item.value : void 0);
+		return parts.every((item) => item !== void 0) ? parts.join("\n") : void 0;
+	}
+	if (isRecord$3(value) && typeof value.value === "string") return value.value;
+}
+function isRange$2(value) {
+	return isRecord$3(value) && isPosition$2(value.start) && isPosition$2(value.end);
+}
+function isPosition$2(value) {
+	return isRecord$3(value) && Number.isInteger(value.line) && Number.isInteger(value.character) && value.line >= 0 && value.character >= 0;
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/protocol/normalize-location.ts
+function normalizeLocation(value) {
+	if (isRecord$2(value) && typeof value.targetUri === "string" && isRange$1(value.targetSelectionRange)) return {
+		uri: value.targetUri,
+		range: value.targetSelectionRange
+	};
+	if (!isRecord$2(value) || typeof value.uri !== "string" || !isRange$1(value.range)) return void 0;
+	return {
+		uri: value.uri,
+		range: value.range
+	};
+}
+function normalizeLocations(value) {
+	return (Array.isArray(value) ? value : value === null || value === void 0 ? [] : [value]).map(normalizeLocation).filter((location) => location !== void 0);
+}
+function isRange$1(value) {
+	return isRecord$2(value) && isPosition$1(value.start) && isPosition$1(value.end);
+}
+function isPosition$1(value) {
+	return isRecord$2(value) && Number.isInteger(value.line) && Number.isInteger(value.character) && value.line >= 0 && value.character >= 0;
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/protocol/normalize-diagnostic.ts
+function normalizeDiagnostic(value, server, fallbackUri) {
+	if (!isRecord$1(value) || !isRange(value.range) || typeof value.message !== "string") return void 0;
+	const uri = typeof value.uri === "string" ? value.uri : fallbackUri;
+	const severity = typeof value.severity === "number" && value.severity >= 1 && value.severity <= 4 ? value.severity : void 0;
+	const code = typeof value.code === "string" || typeof value.code === "number" ? value.code : void 0;
+	return {
+		server,
+		uri,
+		range: value.range,
+		message: value.message,
+		...severity === void 0 ? {} : { severity },
+		...code === void 0 ? {} : { code },
+		...typeof value.source === "string" ? { source: value.source } : {}
+	};
+}
+function normalizeDiagnostics(value, server, fallbackUri) {
+	return (Array.isArray(value) ? value : []).map((item) => normalizeDiagnostic(item, server, fallbackUri)).filter((item) => item !== void 0);
+}
+function isRange(value) {
+	return isRecord$1(value) && isPosition(value.start) && isPosition(value.end);
+}
+function isPosition(value) {
+	return isRecord$1(value) && Number.isInteger(value.line) && Number.isInteger(value.character) && value.line >= 0 && value.character >= 0;
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/protocol/normalize-completion.ts
+function normalizeCompletionItem(value, server) {
+	if (!isRecord(value) || typeof value.label !== "string" || value.label.length === 0) return void 0;
+	return {
+		server,
+		label: value.label,
+		...typeof value.kind === "number" ? { kind: value.kind } : {},
+		...typeof value.detail === "string" ? { detail: value.detail } : {},
+		...typeof value.documentation === "string" ? { documentation: value.documentation } : {},
+		...typeof value.sortText === "string" ? { sortText: value.sortText } : {},
+		...typeof value.filterText === "string" ? { filterText: value.filterText } : {},
+		...typeof value.insertText === "string" ? { insertText: value.insertText } : {},
+		...typeof value.insertTextFormat === "number" ? { insertTextFormat: value.insertTextFormat } : {},
+		...typeof value.deprecated === "boolean" ? { deprecated: value.deprecated } : {}
+	};
+}
+function normalizeCompletion(value, server) {
+	return (isRecord(value) && Array.isArray(value.items) ? value.items : Array.isArray(value) ? value : []).map((item) => normalizeCompletionItem(item, server)).filter((item) => item !== void 0);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/merge/hover.ts
+function mergeHover(primary, auxiliary) {
+	if (!primary && !auxiliary) return null;
+	if (!primary) return auxiliary ? { ...auxiliary } : null;
+	if (!auxiliary) return { ...primary };
+	const contents = [primary.contents, auxiliary.contents].filter((value, index, values) => values.indexOf(value) === index);
+	const range = sameRange(primary.range, auxiliary.range) ? primary.range : void 0;
+	return {
+		server: primary.server,
+		contents: contents.join("\n\n"),
+		...range ? { range } : {}
+	};
+}
+function sameRange(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+
+//#endregion
+//#region src/runtime/webstack-runtime.ts
+const methods = {
+	hover: "textDocument/hover",
+	goToDefinition: "textDocument/definition",
+	findReferences: "textDocument/references",
+	goToImplementation: "textDocument/implementation"
+};
+const clientCapabilities = {
+	general: { positionEncodings: ["utf-16"] },
+	workspace: {
+		configuration: true,
+		workspaceFolders: true,
+		applyEdit: false
+	},
+	textDocument: {
+		synchronization: {
+			dynamicRegistration: false,
+			didSave: false
+		},
+		hover: { contentFormat: ["markdown", "plaintext"] },
+		completion: { completionItem: {
+			snippetSupport: true,
+			documentationFormat: ["markdown", "plaintext"]
+		} },
+		publishDiagnostics: { versionSupport: true },
+		diagnostic: {}
+	}
+};
+var WebstackLspRuntime = class {
+	pool;
+	workspaces = /* @__PURE__ */ new Map();
+	lifetime = new AbortController();
+	live = /* @__PURE__ */ new Map();
+	starts = /* @__PURE__ */ new Map();
+	restarts = /* @__PURE__ */ new Map();
+	constructor(config, fs, subprocess) {
+		this.config = config;
+		this.fs = fs;
+		this.subprocess = subprocess;
+		this.pool = new ServerPool(async (rawId, key, signal) => {
+			const id = rawId, source = this.workspaces.get(key);
+			const spec = await resolveLaunch(id, config, source.workspace);
+			let executable;
+			try {
+				executable = await subprocess.resolveExecutable(spec.command, spec.env, signal);
+			} catch {
+				throwIfAborted(signal);
+				throw new WebstackLspError("LSP_UNAVAILABLE", `${id} executable is unavailable; run dsh-lsp-webstack --json`);
+			}
+			const session = new ServerSession({
+				spawn: () => subprocess.spawn({
+					argv: [executable, ...spec.args],
+					cwd: source.workspace,
+					env: spec.env,
+					stdio: {
+						stdin: "pipe",
+						stdout: "pipe",
+						stderr: { maxBytes: config.limits.maxStderrBytes }
+					},
+					graceMs: config.timeouts.killGraceMs
+				}),
+				initialize: {
+					processId: null,
+					rootUri: source.workspaceUri,
+					workspaceFolders: [{
+						uri: source.workspaceUri,
+						name: "workspace"
+					}],
+					capabilities: clientCapabilities,
+					initializationOptions: initializationOptions(id, config)
+				},
+				configuration: serverConfiguration(id, config),
+				maxMessageBytes: config.limits.maxMessageBytes,
+				shutdown: {
+					shutdownMs: config.timeouts.shutdownMs,
+					killGraceMs: config.timeouts.killGraceMs
+				}
+			});
+			const slot = `${id}\u0000${key}`;
+			if (this.starts.has(slot)) this.restarts.set(id, (this.restarts.get(id) ?? 0) + 1);
+			this.starts.set(slot, (this.starts.get(slot) ?? 0) + 1);
+			for (const [old] of this.live) if (old.state === "STOPPED" || old.state === "FAILED") this.live.delete(old);
+			this.live.set(session, id);
+			return session;
+		});
+	}
+	async navigation(request, signal) {
+		const deadline = this.signal(request.operation === "hover" ? this.config.timeouts.primaryHoverMs : this.config.timeouts.navigationMs, signal);
+		const [source, route] = await this.prepare(request, deadline);
+		this.validatePosition(source.text, request.position);
+		const result = await this.document(route.primary.server, source, route.primary.languageId, deadline, async (session, connection) => {
+			if (!supportsOperation(session.capabilities, request.operation)) throw new WebstackLspError("LSP_UNSUPPORTED_OPERATION", `${route.primary.server} does not support ${request.operation}`);
+			return connection.request(methods[request.operation], {
+				textDocument: { uri: source.uri },
+				position: request.position,
+				...request.operation === "findReferences" ? { context: { includeDeclaration: true } } : {}
+			}, deadline);
+		});
+		if (request.operation !== "hover") return {
+			kind: "locations",
+			locations: normalizeLocations(result),
+			resolvedWorkspaceUri: source.workspaceUri
+		};
+		const primary = normalizeHover(result);
+		if (primary === void 0) throw new WebstackLspError("LSP_MALFORMED_RESPONSE", "invalid hover result");
+		let auxiliary = null;
+		if (this.useTailwind(route, source, request.position)) {
+			const auxSignal = this.signal(this.config.timeouts.auxiliaryHoverMs, signal);
+			try {
+				const value = await this.document("tailwind", source, route.auxiliary.languageId, auxSignal, (_session, connection) => connection.request("textDocument/hover", {
+					textDocument: { uri: source.uri },
+					position: request.position
+				}, auxSignal));
+				auxiliary = normalizeHover(value) ?? null;
+			} catch {
+				throwIfAborted(signal);
+				throwIfAborted(this.lifetime.signal);
+			}
+		}
+		const hover = mergeHover(primary && {
+			...primary,
+			server: route.primary.server
+		}, auxiliary && {
+			...auxiliary,
+			server: "tailwind"
+		});
+		return {
+			kind: "hover",
+			hover: hover ? {
+				contents: hover.contents,
+				...hover.range ? { range: hover.range } : {}
+			} : null
+		};
+	}
+	async completion(request, signal) {
+		const deadline = this.signal(this.config.timeouts.completionMs, signal);
+		const [source, route] = await this.prepare(request, deadline);
+		this.validatePosition(source.text, request.position);
+		const query = (id, language) => this.document(id, source, language, deadline, (session, connection) => {
+			if (!session.capabilities.completionProvider) throw new WebstackLspError("LSP_UNSUPPORTED_OPERATION", `${id} does not support completion`);
+			return connection.request("textDocument/completion", {
+				textDocument: { uri: source.uri },
+				position: request.position,
+				context: {
+					triggerKind: request.triggerKind ?? 1,
+					...request.triggerCharacter ? { triggerCharacter: request.triggerCharacter } : {}
+				}
+			}, deadline);
+		}).then((value) => {
+			const prefix = source.text.split(/\r?\n/)[request.position.line].slice(0, request.position.character).match(/[\w$:@/!\[\]-]+$/)?.[0]?.toLowerCase() ?? "";
+			return normalizeCompletion(value, id).sort((a, b) => Number((b.filterText ?? b.label).toLowerCase().startsWith(prefix)) - Number((a.filterText ?? a.label).toLowerCase().startsWith(prefix)));
+		});
+		const primary = await query(route.primary.server, route.primary.languageId);
+		let auxiliary = [];
+		if (this.useTailwind(route, source, request.position)) try {
+			auxiliary = await query("tailwind", route.auxiliary.languageId);
+		} catch {
+			throwIfAborted(signal);
+			throwIfAborted(this.lifetime.signal);
+		}
+		return mergeCompletions([primary, auxiliary], {
+			maxCompletions: Number.MAX_SAFE_INTEGER,
+			maxResultChars: Number.MAX_SAFE_INTEGER
+		});
+	}
+	async diagnostics(request, signal) {
+		const deadline = this.signal(this.config.timeouts.diagnosticsMs, signal);
+		const [source, route] = await this.prepare(request, deadline);
+		const selected = [route.primary, ...route.auxiliary && this.config.tailwind.enabled ? [route.auxiliary] : []].filter((item) => this.config.servers[item.server].enabled && (!request.servers || request.servers.includes(item.server)));
+		if (!selected.length) throw new WebstackLspError("LSP_UNAVAILABLE", "no selected diagnostic server supports this file");
+		const omittedServers = [];
+		const groups = await Promise.all(selected.map(async (item) => {
+			try {
+				const value = await this.document(item.server, source, item.languageId, deadline, async (session, connection, opened) => {
+					if (session.capabilities.diagnosticProvider) {
+						await opened();
+						return (await connection.request("textDocument/diagnostic", { textDocument: { uri: source.uri } }, deadline))?.items ?? [];
+					}
+					let remove = () => {};
+					const published = new Promise((resolve) => {
+						remove = connection.onNotification((message) => {
+							const p = message.params;
+							if (message.method === "textDocument/publishDiagnostics" && p?.uri === source.uri && (p.version === void 0 || p.version === 1)) resolve(p.diagnostics);
+						});
+					});
+					try {
+						await opened();
+						return await withAbort(published, deadline);
+					} finally {
+						remove();
+					}
+				}, true);
+				return normalizeDiagnostics(value, item.server, source.uri).filter((d) => !request.severity || request.severity === "all" || d.severity === (request.severity === "error" ? 1 : 2));
+			} catch (error) {
+				throwIfAborted(signal);
+				throwIfAborted(this.lifetime.signal);
+				if (item.server === route.primary.server || this.config.missingServerPolicy === "error") throw error;
+				omittedServers.push(item.server);
+				return [];
+			}
+		}));
+		return {
+			...mergeDiagnostics(groups, {
+				maxDiagnostics: Number.MAX_SAFE_INTEGER,
+				maxResultChars: Number.MAX_SAFE_INTEGER
+			}),
+			...omittedServers.length ? { omittedServers: omittedServers.sort() } : {}
+		};
+	}
+	async status() {
+		return {
+			providerId: this.config.providerId,
+			servers: await Promise.all(SERVER_IDS.map(async (id) => {
+				const config = this.config.servers[id];
+				let available = false;
+				try {
+					const launch = await resolveLaunch(id, this.config, ".");
+					await this.subprocess.resolveExecutable(launch.command, launch.env, this.signal(5e3));
+					available = true;
+				} catch {}
+				return {
+					id,
+					enabled: config.enabled && (id !== "tailwind" || this.config.tailwind.enabled),
+					available,
+					source: config.mode,
+					liveWorkspaces: [...this.live].filter(([s, server]) => server === id && s.isUsable()).length,
+					restarts: this.restarts.get(id) ?? 0
+				};
+			}))
+		};
+	}
+	async dispose() {
+		this.lifetime.abort();
+		await this.pool.disposeAll();
+		this.workspaces.clear();
+		this.live.clear();
+	}
+	signal(ms, signal) {
+		return AbortSignal.any([
+			this.lifetime.signal,
+			AbortSignal.timeout(ms),
+			...signal ? [signal] : []
+		]);
+	}
+	async prepare(request, signal) {
+		throwIfAborted(signal);
+		const file = classifyFile(request.filePath, this.config.routing.bladeSuffixes);
+		if (!file) throw new WebstackLspError("LSP_UNAVAILABLE", "unsupported file extension");
+		const source = await readSource(this.fs, request.workspaceRoot, request.filePath, this.config.limits.maxDocumentBytes, signal).catch((error) => {
+			throwIfAborted(signal);
+			throw error;
+		});
+		this.workspaces.set(source.key, {
+			...source,
+			text: ""
+		});
+		return [source, routeFor(file)];
+	}
+	validatePosition(text, position) {
+		const line = text.split(/\r?\n/)[position.line];
+		if (!Number.isSafeInteger(position.line) || !Number.isSafeInteger(position.character) || position.line < 0 || position.character < 0 || line === void 0 || position.character > line.length) throw new RangeError("position is outside document (zero-based UTF-16 required)");
+	}
+	useTailwind(route, source, position) {
+		return !!route.auxiliary && this.config.tailwind.enabled && this.config.servers.tailwind.enabled && (route.primary.languageId === "blade" || this.config.routing.tailwindLanguages.includes(route.primary.languageId) || route.primary.languageId === "css") && (this.config.tailwind.queryStrategy === "always" || hasTailwindCandidate(source.text, position.line, this.config.tailwind.classRegex, position.character, this.config.tailwind.classAttributes));
+	}
+	async document(id, source, language, signal, task, manualOpen = false) {
+		if (!this.config.servers[id].enabled) throw new WebstackLspError("LSP_UNAVAILABLE", `${id} is disabled`);
+		return this.pool.runWithRetry(id, source.key, (session) => session.run(async (connection) => {
+			let opened = false;
+			const open = async () => {
+				opened = true;
+				await connection.notify("textDocument/didOpen", { textDocument: {
+					uri: source.uri,
+					languageId: language,
+					version: 1,
+					text: source.text
+				} });
+			};
+			try {
+				if (!manualOpen) await open();
+				return await task(session, connection, open);
+			} finally {
+				if (opened && connection.isOpen) await connection.notify("textDocument/didClose", { textDocument: { uri: source.uri } }).catch(() => {});
+			}
+		}, signal), signal);
+	}
+};
+
+//#endregion
+//#region src/provider.ts
+const name = "lsp-webstack-provider";
+const inject = [
+	"fs",
+	"lsp",
+	"subprocess"
+];
+const OUTER_EXTENSION_MAP = {
+	".php": "php",
+	".ts": "typescript",
+	".tsx": "typescriptreact",
+	".mts": "typescript",
+	".cts": "typescript",
+	".js": "javascript",
+	".jsx": "javascriptreact",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".svelte": "svelte",
+	".html": "html",
+	".htm": "html",
+	".css": "css",
+	".pcss": "css"
+};
+function createCompositeProvider(runtime, config = { providerId: "webstack" }) {
+	return {
+		id: LspProviderId(config.providerId),
+		extensionToLanguage: { ...OUTER_EXTENSION_MAP },
+		query: (request, signal) => runtime.navigation(request, signal)
+	};
+}
+async function apply(ctx, config = {}) {
+	const resolved = resolveConfig(config);
+	const runtime = new WebstackLspRuntime(resolved, ctx.fs, ctx.subprocess);
+	await ctx.effect(async function* () {
+		yield () => runtime.dispose();
+		if (resolved.missingServerPolicy === "error") {
+			const missing = (await runtime.status()).servers.filter((server) => server.enabled && !server.available);
+			if (missing.length) throw new Error(`unavailable language servers: ${missing.map((server) => server.id).join(", ")}`);
+		}
+		yield ctx.lsp.registerProvider(createCompositeProvider(runtime, resolved));
+		yield ctx.provide("webstackLsp", createWebstackLspService(runtime));
+	}, "webstack LSP provider");
+}
+
+//#endregion
+export { OUTER_EXTENSION_MAP, apply, createCompositeProvider, inject, name };
+//# sourceMappingURL=provider.js.map