@soda-gql/lsp 0.12.0

package/dist/server-BgXl3W41.mjs

@@ -0,0 +1,4345 @@
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createSwcSpanConverter } from "@soda-gql/common";
+import { TypeInfo, buildASTSchema, concatAST, getNamedType, isTypeDefinitionNode, parse, print, visit, visitWithTypeInfo } from "graphql";
+import { readFileSync } from "node:fs";
+import { dirname, resolve, sep } from "node:path";
+import { hashSchema } from "@soda-gql/codegen";
+import { err, ok } from "neverthrow";
+import { findAllConfigFiles, findConfigFile, loadConfig } from "@soda-gql/config";
+import { DidChangeWatchedFilesNotification, FileChangeType, ProposedFeatures, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { createGraphqlSystemIdentifyHelper } from "@soda-gql/builder";
+import ts from "typescript";
+import { getAutocompleteSuggestions, getContextAtPosition, getDefinitionQueryResultForField, getDefinitionQueryResultForFragmentSpread, getDiagnostics, getHoverInformation, getOutline } from "graphql-language-service";
+
+//#region packages/lsp/src/fragment-args-preprocessor.ts
+/**
+* Find the matching closing parenthesis for a balanced group.
+* Handles nested parentheses, string literals, and comments.
+* Returns the index of the closing ')' or -1 if not found.
+*/
+const findMatchingParen = (content, openIndex) => {
+	let depth = 1;
+	let inString = false;
+	for (let i = openIndex + 1; i < content.length; i++) {
+		const ch = content[i];
+		if (ch === undefined) break;
+		if (inString) {
+			if (ch === inString) {
+				let backslashes = 0;
+				for (let j = i - 1; j >= 0 && content[j] === "\\"; j--) {
+					backslashes++;
+				}
+				if (backslashes % 2 === 0) {
+					inString = false;
+				}
+			}
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			inString = ch;
+			continue;
+		}
+		if (ch === "(") {
+			depth++;
+		} else if (ch === ")") {
+			depth--;
+			if (depth === 0) {
+				return i;
+			}
+		}
+	}
+	return -1;
+};
+/**
+* Replace a range [start, end] (inclusive) with spaces, preserving newlines.
+*/
+const replaceWithSpaces = (content, start, end) => {
+	let result = content.slice(0, start);
+	for (let i = start; i <= end; i++) {
+		result += content[i] === "\n" ? "\n" : " ";
+	}
+	result += content.slice(end + 1);
+	return result;
+};
+const FRAGMENT_DEF_PATTERN = /\bfragment\s+(\w+)\s*\(/g;
+const FRAGMENT_DEF_CURRIED_PATTERN = /\bfragment\s+\w+\s+on\s+\w+\s*\(/g;
+const FRAGMENT_SPREAD_PATTERN = /\.\.\.(\w+)\s*\(/g;
+/**
+* Preprocess Fragment Arguments RFC syntax by replacing argument lists with spaces.
+*
+* Transforms:
+* - `fragment UserProfile($showEmail: Boolean = false) on User` → `fragment UserProfile                               on User`
+* - `...UserProfile(showEmail: true)` → `...UserProfile                  `
+*/
+const preprocessFragmentArgs = (content) => {
+	let result = content;
+	let modified = false;
+	let match;
+	FRAGMENT_DEF_PATTERN.lastIndex = 0;
+	while ((match = FRAGMENT_DEF_PATTERN.exec(result)) !== null) {
+		const openParenIndex = match.index + match[0].length - 1;
+		const closeParenIndex = findMatchingParen(result, openParenIndex);
+		if (closeParenIndex === -1) {
+			continue;
+		}
+		const afterParen = result.slice(closeParenIndex + 1).trimStart();
+		if (!afterParen.startsWith("on")) {
+			continue;
+		}
+		result = replaceWithSpaces(result, openParenIndex, closeParenIndex);
+		modified = true;
+		FRAGMENT_DEF_PATTERN.lastIndex = 0;
+	}
+	FRAGMENT_DEF_CURRIED_PATTERN.lastIndex = 0;
+	while ((match = FRAGMENT_DEF_CURRIED_PATTERN.exec(result)) !== null) {
+		const openParenIndex = match.index + match[0].length - 1;
+		const closeParenIndex = findMatchingParen(result, openParenIndex);
+		if (closeParenIndex === -1) {
+			continue;
+		}
+		const afterParen = result.slice(closeParenIndex + 1).trimStart();
+		if (!afterParen.startsWith("{")) {
+			continue;
+		}
+		result = replaceWithSpaces(result, openParenIndex, closeParenIndex);
+		modified = true;
+		FRAGMENT_DEF_CURRIED_PATTERN.lastIndex = 0;
+	}
+	FRAGMENT_SPREAD_PATTERN.lastIndex = 0;
+	while ((match = FRAGMENT_SPREAD_PATTERN.exec(result)) !== null) {
+		const openParenIndex = match.index + match[0].length - 1;
+		const closeParenIndex = findMatchingParen(result, openParenIndex);
+		if (closeParenIndex === -1) {
+			continue;
+		}
+		result = replaceWithSpaces(result, openParenIndex, closeParenIndex);
+		modified = true;
+		FRAGMENT_SPREAD_PATTERN.lastIndex = 0;
+	}
+	return {
+		preprocessed: result,
+		modified
+	};
+};
+
+//#endregion
+//#region packages/lsp/src/document-manager.ts
+/**
+* Document manager: tracks open documents and extracts tagged templates using SWC.
+* @module
+*/
+const OPERATION_KINDS = new Set([
+	"query",
+	"mutation",
+	"subscription",
+	"fragment"
+]);
+const isOperationKind = (value) => OPERATION_KINDS.has(value);
+/**
+* Collect gql identifiers from import declarations.
+* Adapted from builder's collectGqlIdentifiers pattern.
+*/
+const collectGqlIdentifiers = (module, filePath, helper) => {
+	const identifiers = new Set();
+	for (const item of module.body) {
+		let declaration = null;
+		if (item.type === "ImportDeclaration") {
+			declaration = item;
+		} else if ("declaration" in item && item.declaration && item.declaration.type === "ImportDeclaration") {
+			declaration = item.declaration;
+		}
+		if (!declaration) {
+			continue;
+		}
+		if (!helper.isGraphqlSystemImportSpecifier({
+			filePath,
+			specifier: declaration.source.value
+		})) {
+			continue;
+		}
+		for (const specifier of declaration.specifiers ?? []) {
+			if (specifier.type === "ImportSpecifier") {
+				const imported = specifier.imported ? specifier.imported.value : specifier.local.value;
+				if (imported === "gql" && !specifier.imported) {
+					identifiers.add(specifier.local.value);
+				}
+			}
+		}
+	}
+	return identifiers;
+};
+/**
+* Check if a call expression is a gql.{schemaName}(...) call.
+* Returns the schema name if it is, null otherwise.
+*/
+const getGqlCallSchemaName = (identifiers, call) => {
+	const callee = call.callee;
+	if (callee.type !== "MemberExpression") {
+		return null;
+	}
+	const member = callee;
+	if (member.object.type !== "Identifier" || !identifiers.has(member.object.value)) {
+		return null;
+	}
+	if (member.property.type !== "Identifier") {
+		return null;
+	}
+	const firstArg = call.arguments[0];
+	if (!firstArg?.expression || firstArg.expression.type !== "ArrowFunctionExpression") {
+		return null;
+	}
+	return member.property.value;
+};
+/**
+* Extract templates from a gql callback's arrow function body.
+* Handles both expression bodies and block bodies with return statements.
+*/
+const extractTemplatesFromCallback = (arrow, schemaName, spanOffset, converter) => {
+	const templates = [];
+	const processExpression = (expr) => {
+		if (expr.type === "TaggedTemplateExpression") {
+			const tagged = expr;
+			extractFromTaggedTemplate(tagged, schemaName, spanOffset, converter, templates);
+			return;
+		}
+		if (expr.type === "CallExpression") {
+			const call = expr;
+			if (call.callee.type === "TaggedTemplateExpression") {
+				extractFromTaggedTemplate(call.callee, schemaName, spanOffset, converter, templates);
+			}
+		}
+	};
+	if (arrow.body.type !== "BlockStatement") {
+		processExpression(arrow.body);
+		return templates;
+	}
+	for (const stmt of arrow.body.stmts) {
+		if (stmt.type === "ReturnStatement" && stmt.argument) {
+			processExpression(stmt.argument);
+		}
+	}
+	return templates;
+};
+const extractFromTaggedTemplate = (tagged, schemaName, spanOffset, converter, templates) => {
+	if (tagged.tag.type !== "CallExpression") {
+		return;
+	}
+	const tagCall = tagged.tag;
+	if (tagCall.callee.type !== "Identifier") {
+		return;
+	}
+	const kind = tagCall.callee.value;
+	if (!isOperationKind(kind)) {
+		return;
+	}
+	let elementName;
+	let typeName;
+	const firstArg = tagCall.arguments[0]?.expression;
+	if (firstArg?.type === "StringLiteral") {
+		elementName = firstArg.value;
+	}
+	const secondArg = tagCall.arguments[1]?.expression;
+	if (secondArg?.type === "StringLiteral") {
+		typeName = secondArg.value;
+	}
+	const { quasis, expressions } = tagged.template;
+	if (quasis.length === 0) {
+		return;
+	}
+	const parts = [];
+	let contentStart = -1;
+	let contentEnd = -1;
+	for (let i = 0; i < quasis.length; i++) {
+		const quasi = quasis[i];
+		if (!quasi) {
+			continue;
+		}
+		const quasiStart = converter.byteOffsetToCharIndex(quasi.span.start - spanOffset);
+		const quasiEnd = converter.byteOffsetToCharIndex(quasi.span.end - spanOffset);
+		if (contentStart === -1) {
+			contentStart = quasiStart;
+		}
+		contentEnd = quasiEnd;
+		const quasiContent = quasi.cooked ?? quasi.raw;
+		parts.push(quasiContent);
+		if (i < expressions.length) {
+			parts.push(`__FRAG_SPREAD_${i}__`);
+		}
+	}
+	if (contentStart === -1 || contentEnd === -1) {
+		return;
+	}
+	const content = parts.join("");
+	templates.push({
+		contentRange: {
+			start: contentStart,
+			end: contentEnd
+		},
+		schemaName,
+		kind,
+		content,
+		...elementName !== undefined ? { elementName } : {},
+		...typeName !== undefined ? { typeName } : {}
+	});
+};
+/**
+* Walk AST to find gql calls and extract templates.
+* Adapted from builder's unwrapMethodChains + visit pattern.
+*/
+const walkAndExtract = (node, identifiers, spanOffset, converter) => {
+	const templates = [];
+	const visit$1 = (n) => {
+		if (!n || typeof n !== "object") {
+			return;
+		}
+		if ("type" in n && n.type === "CallExpression") {
+			const gqlCall = findGqlCall(identifiers, n);
+			if (gqlCall) {
+				const schemaName = getGqlCallSchemaName(identifiers, gqlCall);
+				if (schemaName) {
+					const arrow = gqlCall.arguments[0]?.expression;
+					templates.push(...extractTemplatesFromCallback(arrow, schemaName, spanOffset, converter));
+				}
+				return;
+			}
+		}
+		if (Array.isArray(n)) {
+			for (const item of n) {
+				visit$1(item);
+			}
+			return;
+		}
+		for (const key of Object.keys(n)) {
+			if (key === "span" || key === "type") {
+				continue;
+			}
+			const value = n[key];
+			if (value && typeof value === "object") {
+				visit$1(value);
+			}
+		}
+	};
+	visit$1(node);
+	return templates;
+};
+/**
+* Find the innermost gql call, unwrapping method chains like .attach().
+*/
+const findGqlCall = (identifiers, node) => {
+	if (!node || node.type !== "CallExpression") {
+		return null;
+	}
+	const call = node;
+	if (getGqlCallSchemaName(identifiers, call) !== null) {
+		return call;
+	}
+	const callee = call.callee;
+	if (callee.type !== "MemberExpression") {
+		return null;
+	}
+	return findGqlCall(identifiers, callee.object);
+};
+/**
+* Index fragment definitions from extracted templates.
+* Parses each fragment template to extract FragmentDefinitionNode for cross-file resolution.
+*/
+/**
+* Reconstruct full GraphQL source from an extracted template.
+* Prepends the definition header from curried tag call arguments.
+*/
+const reconstructGraphql = (template) => {
+	const content = template.content;
+	if (template.elementName) {
+		if (template.kind === "fragment" && template.typeName) {
+			return `fragment ${template.elementName} on ${template.typeName} ${content}`;
+		}
+		return `${template.kind} ${template.elementName} ${content}`;
+	}
+	return content;
+};
+const indexFragments = (uri, templates, source) => {
+	const fragments = [];
+	for (const template of templates) {
+		if (template.kind !== "fragment") {
+			continue;
+		}
+		const reconstructed = reconstructGraphql(template);
+		const headerLen = reconstructed.length - template.content.length;
+		const { preprocessed } = preprocessFragmentArgs(reconstructed);
+		try {
+			const ast = parse(preprocessed, { noLocation: false });
+			for (const def of ast.definitions) {
+				if (def.kind === "FragmentDefinition") {
+					fragments.push({
+						uri,
+						schemaName: template.schemaName,
+						fragmentName: def.name.value,
+						definition: def,
+						content: preprocessed,
+						contentRange: template.contentRange,
+						tsSource: source,
+						headerLen
+					});
+				}
+			}
+		} catch {}
+	}
+	return fragments;
+};
+/** Create a document manager that tracks open documents and extracts templates. */
+const createDocumentManager = (helper, swcOptions) => {
+	let parseSyncFn = swcOptions?.parseSync !== undefined ? swcOptions.parseSync ?? null : null;
+	let swcLoadAttempted = swcOptions?.parseSync !== undefined;
+	let swcUnavailable = swcOptions?.parseSync === null;
+	const getParseSync = () => {
+		if (!swcLoadAttempted) {
+			swcLoadAttempted = true;
+			const resolveBases = swcOptions?.resolveFrom ? [swcOptions.resolveFrom, import.meta.url] : [import.meta.url];
+			for (const base of resolveBases) {
+				try {
+					const localRequire = createRequire(base);
+					const candidate = localRequire("@swc/core")?.parseSync;
+					if (typeof candidate === "function") {
+						parseSyncFn = candidate;
+						return parseSyncFn;
+					}
+				} catch {}
+			}
+			swcUnavailable = true;
+		}
+		return parseSyncFn;
+	};
+	/** Wrap SWC parseSync (which throws) to return null on failure. */
+	const safeParseSync = (source, tsx) => {
+		const parseSync = getParseSync();
+		if (!parseSync) return null;
+		try {
+			const result = parseSync(source, {
+				syntax: "typescript",
+				tsx,
+				decorators: false,
+				dynamicImport: true
+			});
+			return result.type === "Module" ? result : null;
+		} catch {
+			return null;
+		}
+	};
+	const cache = new Map();
+	const fragmentIndex = new Map();
+	const extractTemplates = (uri, source) => {
+		const isTsx = uri.endsWith(".tsx");
+		const program = safeParseSync(source, isTsx);
+		if (!program) {
+			return [];
+		}
+		const converter = createSwcSpanConverter(source);
+		const spanOffset = program.span.end - converter.byteLength + 1;
+		const filePath = uri.startsWith("file://") ? fileURLToPath(uri) : uri;
+		const gqlIdentifiers = collectGqlIdentifiers(program, filePath, helper);
+		if (gqlIdentifiers.size === 0) {
+			return [];
+		}
+		return walkAndExtract(program, gqlIdentifiers, spanOffset, converter);
+	};
+	return {
+		update: (uri, version, source) => {
+			const templates = extractTemplates(uri, source);
+			const state = {
+				uri,
+				version,
+				source,
+				templates,
+				...swcUnavailable ? { swcUnavailable: true } : {}
+			};
+			cache.set(uri, state);
+			if (swcUnavailable) {
+				fragmentIndex.delete(uri);
+			} else {
+				fragmentIndex.set(uri, indexFragments(uri, templates, source));
+			}
+			return state;
+		},
+		get: (uri) => cache.get(uri),
+		remove: (uri) => {
+			cache.delete(uri);
+			fragmentIndex.delete(uri);
+		},
+		findTemplateAtOffset: (uri, offset) => {
+			const state = cache.get(uri);
+			if (!state) {
+				return undefined;
+			}
+			return state.templates.find((t) => offset >= t.contentRange.start && offset <= t.contentRange.end);
+		},
+		getExternalFragments: (uri, schemaName) => {
+			const result = [];
+			for (const [fragmentUri, fragments] of fragmentIndex) {
+				if (fragmentUri === uri) {
+					continue;
+				}
+				for (const fragment of fragments) {
+					if (fragment.schemaName === schemaName) {
+						result.push(fragment);
+					}
+				}
+			}
+			return result;
+		},
+		getAllFragments: (schemaName) => {
+			const result = [];
+			for (const [, fragments] of fragmentIndex) {
+				for (const fragment of fragments) {
+					if (fragment.schemaName === schemaName) {
+						result.push(fragment);
+					}
+				}
+			}
+			return result;
+		},
+		findFragmentSpreadLocations: (fragmentName, schemaName) => {
+			const locations = [];
+			for (const [uri, state] of cache) {
+				for (const template of state.templates) {
+					if (template.schemaName !== schemaName) {
+						continue;
+					}
+					const reconstructed = reconstructGraphql(template);
+					const headerLen = reconstructed.length - template.content.length;
+					const { preprocessed } = preprocessFragmentArgs(reconstructed);
+					try {
+						const ast = parse(preprocessed, { noLocation: false });
+						visit(ast, { FragmentSpread(node) {
+							if (node.name.value === fragmentName && node.name.loc) {
+								locations.push({
+									uri,
+									tsSource: state.source,
+									template,
+									nameOffset: node.name.loc.start - headerLen,
+									nameLength: fragmentName.length
+								});
+							}
+						} });
+					} catch {
+						const pattern = new RegExp(`\\.\\.\\.${fragmentName}\\b`, "g");
+						let match = null;
+						while ((match = pattern.exec(preprocessed)) !== null) {
+							locations.push({
+								uri,
+								tsSource: state.source,
+								template,
+								nameOffset: match.index + 3 - headerLen,
+								nameLength: fragmentName.length
+							});
+						}
+					}
+				}
+			}
+			return locations;
+		}
+	};
+};
+
+//#endregion
+//#region packages/lsp/src/errors.ts
+/** Error constructor helpers for concise error creation. */
+const lspErrors = {
+	configLoadFailed: (message, cause) => ({
+		code: "CONFIG_LOAD_FAILED",
+		message,
+		cause
+	}),
+	schemaLoadFailed: (schemaName, message, cause) => ({
+		code: "SCHEMA_LOAD_FAILED",
+		message: message ?? `Failed to load schema: ${schemaName}`,
+		schemaName,
+		cause
+	}),
+	schemaBuildFailed: (schemaName, message, cause) => ({
+		code: "SCHEMA_BUILD_FAILED",
+		message: message ?? `Failed to build schema: ${schemaName}`,
+		schemaName,
+		cause
+	}),
+	schemaNotConfigured: (schemaName) => ({
+		code: "SCHEMA_NOT_CONFIGURED",
+		message: `Schema "${schemaName}" is not configured in soda-gql.config`,
+		schemaName
+	}),
+	parseFailed: (uri, message, cause) => ({
+		code: "PARSE_FAILED",
+		message: message ?? `Failed to parse: ${uri}`,
+		uri,
+		cause
+	}),
+	internalInvariant: (message, context, cause) => ({
+		code: "INTERNAL_INVARIANT",
+		message,
+		context,
+		cause
+	}),
+	swcResolutionFailed: (message) => ({
+		code: "SWC_RESOLUTION_FAILED",
+		message: message ?? "@swc/core not found. Install @soda-gql/builder (which provides @swc/core) in your project and restart the LSP server to enable template extraction."
+	})
+};
+
+//#endregion
+//#region packages/lsp/src/position-mapping.ts
+/** Compute byte offsets for the start of each line in the source text. */
+const computeLineOffsets = (source) => {
+	const offsets = [0];
+	for (let i = 0; i < source.length; i++) {
+		if (source.charCodeAt(i) === 10) {
+			offsets.push(i + 1);
+		}
+	}
+	return offsets;
+};
+/** Convert a Position to a byte offset within the source text. */
+const positionToOffset$1 = (lineOffsets, position) => {
+	if (position.line < 0 || position.line >= lineOffsets.length) {
+		return -1;
+	}
+	return (lineOffsets[position.line] ?? 0) + position.character;
+};
+/** Convert a byte offset to a Position within the source text. */
+const offsetToPosition = (lineOffsets, offset) => {
+	let low = 0;
+	let high = lineOffsets.length - 1;
+	while (low < high) {
+		const mid = Math.ceil((low + high) / 2);
+		if ((lineOffsets[mid] ?? 0) <= offset) {
+			low = mid;
+		} else {
+			high = mid - 1;
+		}
+	}
+	return {
+		line: low,
+		character: offset - (lineOffsets[low] ?? 0)
+	};
+};
+/** Convert a Position to an IPosition compatible with graphql-language-service. */
+const toIPosition = (pos) => {
+	const p = {
+		line: pos.line,
+		character: pos.character,
+		setLine: (l) => {
+			p.line = l;
+		},
+		setCharacter: (c) => {
+			p.character = c;
+		},
+		lessThanOrEqualTo: (other) => p.line < other.line || p.line === other.line && p.character <= other.character
+	};
+	return p;
+};
+/** Create a bidirectional position mapper between TS file and GraphQL content. */
+const createPositionMapper = (input) => {
+	const { tsSource, contentStartOffset, graphqlContent } = input;
+	const tsLineOffsets = computeLineOffsets(tsSource);
+	const gqlLineOffsets = computeLineOffsets(graphqlContent);
+	return {
+		tsToGraphql: (tsPosition) => {
+			const tsOffset = positionToOffset$1(tsLineOffsets, tsPosition);
+			if (tsOffset < 0) {
+				return null;
+			}
+			const gqlOffset = tsOffset - contentStartOffset;
+			if (gqlOffset < 0 || gqlOffset > graphqlContent.length) {
+				return null;
+			}
+			return offsetToPosition(gqlLineOffsets, gqlOffset);
+		},
+		graphqlToTs: (gqlPosition) => {
+			const gqlOffset = positionToOffset$1(gqlLineOffsets, gqlPosition);
+			const tsOffset = gqlOffset + contentStartOffset;
+			return offsetToPosition(tsLineOffsets, tsOffset);
+		}
+	};
+};
+
+//#endregion
+//#region packages/lsp/src/schema-resolver.ts
+/**
+* Schema resolver: maps schema names to GraphQLSchema objects.
+* @module
+*/
+/** Wrap buildASTSchema (which throws) in a Result. */
+const safeBuildASTSchema = (schemaName, documentNode) => {
+	try {
+		return ok(buildASTSchema(documentNode));
+	} catch (e) {
+		return err(lspErrors.schemaBuildFailed(schemaName, e instanceof Error ? e.message : String(e), e));
+	}
+};
+const loadAndBuildSchema = (schemaName, schemaPaths) => {
+	const documents = [];
+	const files = [];
+	for (const schemaPath of schemaPaths) {
+		const resolvedPath = resolve(schemaPath);
+		try {
+			const content = readFileSync(resolvedPath, "utf8");
+			documents.push(parse(content));
+			files.push({
+				filePath: resolvedPath,
+				content
+			});
+		} catch (e) {
+			return err(lspErrors.schemaLoadFailed(schemaName, e instanceof Error ? e.message : String(e)));
+		}
+	}
+	const documentNode = concatAST(documents);
+	const hash = hashSchema(documentNode);
+	const buildResult = safeBuildASTSchema(schemaName, documentNode);
+	if (buildResult.isErr()) {
+		return err(buildResult.error);
+	}
+	return ok({
+		name: schemaName,
+		schema: buildResult.value,
+		documentNode,
+		hash,
+		files
+	});
+};
+/** Create a schema resolver from config. Loads all schemas eagerly. */
+const createSchemaResolver = (config) => {
+	const cache = new Map();
+	for (const [name, schemaConfig] of Object.entries(config.schemas)) {
+		const result = loadAndBuildSchema(name, schemaConfig.schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		cache.set(name, result.value);
+	}
+	const resolver = {
+		getSchema: (schemaName) => cache.get(schemaName),
+		getSchemaNames: () => [...cache.keys()],
+		reloadSchema: (schemaName) => {
+			const schemaConfig = config.schemas[schemaName];
+			if (!schemaConfig) {
+				return err(lspErrors.schemaNotConfigured(schemaName));
+			}
+			const result = loadAndBuildSchema(schemaName, schemaConfig.schema);
+			if (result.isErr()) {
+				return err(result.error);
+			}
+			cache.set(schemaName, result.value);
+			return ok(result.value);
+		},
+		reloadAll: () => {
+			const errors = [];
+			for (const [name, schemaConfig] of Object.entries(config.schemas)) {
+				const result = loadAndBuildSchema(name, schemaConfig.schema);
+				if (result.isErr()) {
+					errors.push(result.error);
+				} else {
+					cache.set(name, result.value);
+				}
+			}
+			return errors.length > 0 ? err(errors) : ok(undefined);
+		}
+	};
+	return ok(resolver);
+};
+
+//#endregion
+//#region packages/lsp/src/config-registry.ts
+/**
+* Config registry: maps document URIs to their nearest config context.
+* Supports multiple soda-gql configs in a monorepo workspace.
+* @module
+*/
+const createConfigRegistry = (configPaths) => {
+	const sortedPaths = [...configPaths].sort((a, b) => b.length - a.length);
+	const contexts = new Map();
+	for (const configPath of sortedPaths) {
+		const configResult = loadConfig(configPath);
+		if (configResult.isErr()) {
+			return err(lspErrors.configLoadFailed(`Failed to load config ${configPath}: ${configResult.error.message}`, configResult.error));
+		}
+		const config = configResult.value;
+		const helper = createGraphqlSystemIdentifyHelper(config);
+		const resolverResult = createSchemaResolver(config);
+		if (resolverResult.isErr()) {
+			return err(resolverResult.error);
+		}
+		contexts.set(configPath, {
+			configPath,
+			config,
+			helper,
+			schemaResolver: resolverResult.value,
+			documentManager: createDocumentManager(helper, { resolveFrom: configPath })
+		});
+	}
+	const uriCache = new Map();
+	const resolveConfigPath = (dirPath) => {
+		const cached = uriCache.get(dirPath);
+		if (cached !== undefined) {
+			return cached;
+		}
+		for (const configPath of sortedPaths) {
+			const configDir = dirname(configPath);
+			if (dirPath === configDir || dirPath.startsWith(`${configDir}${sep}`)) {
+				uriCache.set(dirPath, configPath);
+				return configPath;
+			}
+		}
+		uriCache.set(dirPath, null);
+		return null;
+	};
+	return ok({
+		resolveForUri: (uri) => {
+			const filePath = uri.startsWith("file://") ? fileURLToPath(uri) : uri;
+			const dirPath = dirname(filePath);
+			const configPath = resolveConfigPath(dirPath);
+			return configPath ? contexts.get(configPath) : undefined;
+		},
+		getAllContexts: () => [...contexts.values()],
+		reloadSchemas: (configPath) => {
+			const ctx = contexts.get(configPath);
+			if (!ctx) {
+				return err([lspErrors.configLoadFailed(`Config not found: ${configPath}`)]);
+			}
+			return ctx.schemaResolver.reloadAll();
+		},
+		reloadAllSchemas: () => {
+			const errors = [];
+			for (const ctx of contexts.values()) {
+				const result = ctx.schemaResolver.reloadAll();
+				if (result.isErr()) {
+					errors.push(...result.error);
+				}
+			}
+			return errors.length > 0 ? err(errors) : ok(undefined);
+		}
+	});
+};
+
+//#endregion
+//#region node_modules/vscode-languageserver-types/lib/esm/main.js
+var DocumentUri;
+(function(DocumentUri$1) {
+	function is(value) {
+		return typeof value === "string";
+	}
+	DocumentUri$1.is = is;
+})(DocumentUri || (DocumentUri = {}));
+var URI;
+(function(URI$1) {
+	function is(value) {
+		return typeof value === "string";
+	}
+	URI$1.is = is;
+})(URI || (URI = {}));
+var integer;
+(function(integer$1) {
+	integer$1.MIN_VALUE = -2147483648;
+	integer$1.MAX_VALUE = 2147483647;
+	function is(value) {
+		return typeof value === "number" && integer$1.MIN_VALUE <= value && value <= integer$1.MAX_VALUE;
+	}
+	integer$1.is = is;
+})(integer || (integer = {}));
+var uinteger;
+(function(uinteger$1) {
+	uinteger$1.MIN_VALUE = 0;
+	uinteger$1.MAX_VALUE = 2147483647;
+	function is(value) {
+		return typeof value === "number" && uinteger$1.MIN_VALUE <= value && value <= uinteger$1.MAX_VALUE;
+	}
+	uinteger$1.is = is;
+})(uinteger || (uinteger = {}));
+/**
+* The Position namespace provides helper functions to work with
+* {@link Position} literals.
+*/
+var Position;
+(function(Position$1) {
+	/**
+	* Creates a new Position literal from the given line and character.
+	* @param line The position's line.
+	* @param character The position's character.
+	*/
+	function create(line, character) {
+		if (line === Number.MAX_VALUE) {
+			line = uinteger.MAX_VALUE;
+		}
+		if (character === Number.MAX_VALUE) {
+			character = uinteger.MAX_VALUE;
+		}
+		return {
+			line,
+			character
+		};
+	}
+	Position$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link Position} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
+	}
+	Position$1.is = is;
+})(Position || (Position = {}));
+/**
+* The Range namespace provides helper functions to work with
+* {@link Range} literals.
+*/
+var Range;
+(function(Range$1) {
+	function create(one, two, three, four) {
+		if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
+			return {
+				start: Position.create(one, two),
+				end: Position.create(three, four)
+			};
+		} else if (Position.is(one) && Position.is(two)) {
+			return {
+				start: one,
+				end: two
+			};
+		} else {
+			throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
+		}
+	}
+	Range$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link Range} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
+	}
+	Range$1.is = is;
+})(Range || (Range = {}));
+/**
+* The Location namespace provides helper functions to work with
+* {@link Location} literals.
+*/
+var Location;
+(function(Location$1) {
+	/**
+	* Creates a Location literal.
+	* @param uri The location's uri.
+	* @param range The location's range.
+	*/
+	function create(uri, range) {
+		return {
+			uri,
+			range
+		};
+	}
+	Location$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link Location} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
+	}
+	Location$1.is = is;
+})(Location || (Location = {}));
+/**
+* The LocationLink namespace provides helper functions to work with
+* {@link LocationLink} literals.
+*/
+var LocationLink;
+(function(LocationLink$1) {
+	/**
+	* Creates a LocationLink literal.
+	* @param targetUri The definition's uri.
+	* @param targetRange The full range of the definition.
+	* @param targetSelectionRange The span of the symbol definition at the target.
+	* @param originSelectionRange The span of the symbol being defined in the originating source file.
+	*/
+	function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
+		return {
+			targetUri,
+			targetRange,
+			targetSelectionRange,
+			originSelectionRange
+		};
+	}
+	LocationLink$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link LocationLink} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri) && Range.is(candidate.targetSelectionRange) && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
+	}
+	LocationLink$1.is = is;
+})(LocationLink || (LocationLink = {}));
+/**
+* The Color namespace provides helper functions to work with
+* {@link Color} literals.
+*/
+var Color;
+(function(Color$1) {
+	/**
+	* Creates a new Color literal.
+	*/
+	function create(red, green, blue, alpha) {
+		return {
+			red,
+			green,
+			blue,
+			alpha
+		};
+	}
+	Color$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link Color} interface.
+	*/
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
+	}
+	Color$1.is = is;
+})(Color || (Color = {}));
+/**
+* The ColorInformation namespace provides helper functions to work with
+* {@link ColorInformation} literals.
+*/
+var ColorInformation;
+(function(ColorInformation$1) {
+	/**
+	* Creates a new ColorInformation literal.
+	*/
+	function create(range, color) {
+		return {
+			range,
+			color
+		};
+	}
+	ColorInformation$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link ColorInformation} interface.
+	*/
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);
+	}
+	ColorInformation$1.is = is;
+})(ColorInformation || (ColorInformation = {}));
+/**
+* The Color namespace provides helper functions to work with
+* {@link ColorPresentation} literals.
+*/
+var ColorPresentation;
+(function(ColorPresentation$1) {
+	/**
+	* Creates a new ColorInformation literal.
+	*/
+	function create(label, textEdit, additionalTextEdits) {
+		return {
+			label,
+			textEdit,
+			additionalTextEdits
+		};
+	}
+	ColorPresentation$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link ColorInformation} interface.
+	*/
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
+	}
+	ColorPresentation$1.is = is;
+})(ColorPresentation || (ColorPresentation = {}));
+/**
+* A set of predefined range kinds.
+*/
+var FoldingRangeKind;
+(function(FoldingRangeKind$1) {
+	/**
+	* Folding range for a comment
+	*/
+	FoldingRangeKind$1.Comment = "comment";
+	/**
+	* Folding range for an import or include
+	*/
+	FoldingRangeKind$1.Imports = "imports";
+	/**
+	* Folding range for a region (e.g. `#region`)
+	*/
+	FoldingRangeKind$1.Region = "region";
+})(FoldingRangeKind || (FoldingRangeKind = {}));
+/**
+* The folding range namespace provides helper functions to work with
+* {@link FoldingRange} literals.
+*/
+var FoldingRange;
+(function(FoldingRange$1) {
+	/**
+	* Creates a new FoldingRange literal.
+	*/
+	function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
+		const result = {
+			startLine,
+			endLine
+		};
+		if (Is.defined(startCharacter)) {
+			result.startCharacter = startCharacter;
+		}
+		if (Is.defined(endCharacter)) {
+			result.endCharacter = endCharacter;
+		}
+		if (Is.defined(kind)) {
+			result.kind = kind;
+		}
+		if (Is.defined(collapsedText)) {
+			result.collapsedText = collapsedText;
+		}
+		return result;
+	}
+	FoldingRange$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link FoldingRange} interface.
+	*/
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
+	}
+	FoldingRange$1.is = is;
+})(FoldingRange || (FoldingRange = {}));
+/**
+* The DiagnosticRelatedInformation namespace provides helper functions to work with
+* {@link DiagnosticRelatedInformation} literals.
+*/
+var DiagnosticRelatedInformation;
+(function(DiagnosticRelatedInformation$1) {
+	/**
+	* Creates a new DiagnosticRelatedInformation literal.
+	*/
+	function create(location, message) {
+		return {
+			location,
+			message
+		};
+	}
+	DiagnosticRelatedInformation$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link DiagnosticRelatedInformation} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
+	}
+	DiagnosticRelatedInformation$1.is = is;
+})(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
+/**
+* The diagnostic's severity.
+*/
+var DiagnosticSeverity;
+(function(DiagnosticSeverity$1) {
+	/**
+	* Reports an error.
+	*/
+	DiagnosticSeverity$1.Error = 1;
+	/**
+	* Reports a warning.
+	*/
+	DiagnosticSeverity$1.Warning = 2;
+	/**
+	* Reports an information.
+	*/
+	DiagnosticSeverity$1.Information = 3;
+	/**
+	* Reports a hint.
+	*/
+	DiagnosticSeverity$1.Hint = 4;
+})(DiagnosticSeverity || (DiagnosticSeverity = {}));
+/**
+* The diagnostic tags.
+*
+* @since 3.15.0
+*/
+var DiagnosticTag;
+(function(DiagnosticTag$1) {
+	/**
+	* Unused or unnecessary code.
+	*
+	* Clients are allowed to render diagnostics with this tag faded out instead of having
+	* an error squiggle.
+	*/
+	DiagnosticTag$1.Unnecessary = 1;
+	/**
+	* Deprecated or obsolete code.
+	*
+	* Clients are allowed to rendered diagnostics with this tag strike through.
+	*/
+	DiagnosticTag$1.Deprecated = 2;
+})(DiagnosticTag || (DiagnosticTag = {}));
+/**
+* The CodeDescription namespace provides functions to deal with descriptions for diagnostic codes.
+*
+* @since 3.16.0
+*/
+var CodeDescription;
+(function(CodeDescription$1) {
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && Is.string(candidate.href);
+	}
+	CodeDescription$1.is = is;
+})(CodeDescription || (CodeDescription = {}));
+/**
+* The Diagnostic namespace provides helper functions to work with
+* {@link Diagnostic} literals.
+*/
+var Diagnostic;
+(function(Diagnostic$1) {
+	/**
+	* Creates a new Diagnostic literal.
+	*/
+	function create(range, message, severity, code, source, relatedInformation) {
+		let result = {
+			range,
+			message
+		};
+		if (Is.defined(severity)) {
+			result.severity = severity;
+		}
+		if (Is.defined(code)) {
+			result.code = code;
+		}
+		if (Is.defined(source)) {
+			result.source = source;
+		}
+		if (Is.defined(relatedInformation)) {
+			result.relatedInformation = relatedInformation;
+		}
+		return result;
+	}
+	Diagnostic$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link Diagnostic} interface.
+	*/
+	function is(value) {
+		var _a;
+		let candidate = value;
+		return Is.defined(candidate) && Range.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
+	}
+	Diagnostic$1.is = is;
+})(Diagnostic || (Diagnostic = {}));
+/**
+* The Command namespace provides helper functions to work with
+* {@link Command} literals.
+*/
+var Command;
+(function(Command$1) {
+	/**
+	* Creates a new Command literal.
+	*/
+	function create(title, command, ...args) {
+		let result = {
+			title,
+			command
+		};
+		if (Is.defined(args) && args.length > 0) {
+			result.arguments = args;
+		}
+		return result;
+	}
+	Command$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link Command} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
+	}
+	Command$1.is = is;
+})(Command || (Command = {}));
+/**
+* The TextEdit namespace provides helper function to create replace,
+* insert and delete edits more easily.
+*/
+var TextEdit;
+(function(TextEdit$1) {
+	/**
+	* Creates a replace text edit.
+	* @param range The range of text to be replaced.
+	* @param newText The new text.
+	*/
+	function replace(range, newText) {
+		return {
+			range,
+			newText
+		};
+	}
+	TextEdit$1.replace = replace;
+	/**
+	* Creates an insert text edit.
+	* @param position The position to insert the text at.
+	* @param newText The text to be inserted.
+	*/
+	function insert(position, newText) {
+		return {
+			range: {
+				start: position,
+				end: position
+			},
+			newText
+		};
+	}
+	TextEdit$1.insert = insert;
+	/**
+	* Creates a delete text edit.
+	* @param range The range of text to be deleted.
+	*/
+	function del(range) {
+		return {
+			range,
+			newText: ""
+		};
+	}
+	TextEdit$1.del = del;
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range.is(candidate.range);
+	}
+	TextEdit$1.is = is;
+})(TextEdit || (TextEdit = {}));
+var ChangeAnnotation;
+(function(ChangeAnnotation$1) {
+	function create(label, needsConfirmation, description) {
+		const result = { label };
+		if (needsConfirmation !== undefined) {
+			result.needsConfirmation = needsConfirmation;
+		}
+		if (description !== undefined) {
+			result.description = description;
+		}
+		return result;
+	}
+	ChangeAnnotation$1.create = create;
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === undefined) && (Is.string(candidate.description) || candidate.description === undefined);
+	}
+	ChangeAnnotation$1.is = is;
+})(ChangeAnnotation || (ChangeAnnotation = {}));
+var ChangeAnnotationIdentifier;
+(function(ChangeAnnotationIdentifier$1) {
+	function is(value) {
+		const candidate = value;
+		return Is.string(candidate);
+	}
+	ChangeAnnotationIdentifier$1.is = is;
+})(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
+var AnnotatedTextEdit;
+(function(AnnotatedTextEdit$1) {
+	/**
+	* Creates an annotated replace text edit.
+	*
+	* @param range The range of text to be replaced.
+	* @param newText The new text.
+	* @param annotation The annotation.
+	*/
+	function replace(range, newText, annotation) {
+		return {
+			range,
+			newText,
+			annotationId: annotation
+		};
+	}
+	AnnotatedTextEdit$1.replace = replace;
+	/**
+	* Creates an annotated insert text edit.
+	*
+	* @param position The position to insert the text at.
+	* @param newText The text to be inserted.
+	* @param annotation The annotation.
+	*/
+	function insert(position, newText, annotation) {
+		return {
+			range: {
+				start: position,
+				end: position
+			},
+			newText,
+			annotationId: annotation
+		};
+	}
+	AnnotatedTextEdit$1.insert = insert;
+	/**
+	* Creates an annotated delete text edit.
+	*
+	* @param range The range of text to be deleted.
+	* @param annotation The annotation.
+	*/
+	function del(range, annotation) {
+		return {
+			range,
+			newText: "",
+			annotationId: annotation
+		};
+	}
+	AnnotatedTextEdit$1.del = del;
+	function is(value) {
+		const candidate = value;
+		return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
+	}
+	AnnotatedTextEdit$1.is = is;
+})(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
+/**
+* The TextDocumentEdit namespace provides helper function to create
+* an edit that manipulates a text document.
+*/
+var TextDocumentEdit;
+(function(TextDocumentEdit$1) {
+	/**
+	* Creates a new `TextDocumentEdit`
+	*/
+	function create(textDocument, edits) {
+		return {
+			textDocument,
+			edits
+		};
+	}
+	TextDocumentEdit$1.create = create;
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
+	}
+	TextDocumentEdit$1.is = is;
+})(TextDocumentEdit || (TextDocumentEdit = {}));
+var CreateFile;
+(function(CreateFile$1) {
+	function create(uri, options, annotation) {
+		let result = {
+			kind: "create",
+			uri
+		};
+		if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {
+			result.options = options;
+		}
+		if (annotation !== undefined) {
+			result.annotationId = annotation;
+		}
+		return result;
+	}
+	CreateFile$1.create = create;
+	function is(value) {
+		let candidate = value;
+		return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === undefined || (candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
+	}
+	CreateFile$1.is = is;
+})(CreateFile || (CreateFile = {}));
+var RenameFile;
+(function(RenameFile$1) {
+	function create(oldUri, newUri, options, annotation) {
+		let result = {
+			kind: "rename",
+			oldUri,
+			newUri
+		};
+		if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {
+			result.options = options;
+		}
+		if (annotation !== undefined) {
+			result.annotationId = annotation;
+		}
+		return result;
+	}
+	RenameFile$1.create = create;
+	function is(value) {
+		let candidate = value;
+		return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === undefined || (candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
+	}
+	RenameFile$1.is = is;
+})(RenameFile || (RenameFile = {}));
+var DeleteFile;
+(function(DeleteFile$1) {
+	function create(uri, options, annotation) {
+		let result = {
+			kind: "delete",
+			uri
+		};
+		if (options !== undefined && (options.recursive !== undefined || options.ignoreIfNotExists !== undefined)) {
+			result.options = options;
+		}
+		if (annotation !== undefined) {
+			result.annotationId = annotation;
+		}
+		return result;
+	}
+	DeleteFile$1.create = create;
+	function is(value) {
+		let candidate = value;
+		return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === undefined || (candidate.options.recursive === undefined || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === undefined || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
+	}
+	DeleteFile$1.is = is;
+})(DeleteFile || (DeleteFile = {}));
+var WorkspaceEdit;
+(function(WorkspaceEdit$1) {
+	function is(value) {
+		let candidate = value;
+		return candidate && (candidate.changes !== undefined || candidate.documentChanges !== undefined) && (candidate.documentChanges === undefined || candidate.documentChanges.every((change) => {
+			if (Is.string(change.kind)) {
+				return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
+			} else {
+				return TextDocumentEdit.is(change);
+			}
+		}));
+	}
+	WorkspaceEdit$1.is = is;
+})(WorkspaceEdit || (WorkspaceEdit = {}));
+var TextEditChangeImpl = class {
+	constructor(edits, changeAnnotations) {
+		this.edits = edits;
+		this.changeAnnotations = changeAnnotations;
+	}
+	insert(position, newText, annotation) {
+		let edit;
+		let id;
+		if (annotation === undefined) {
+			edit = TextEdit.insert(position, newText);
+		} else if (ChangeAnnotationIdentifier.is(annotation)) {
+			id = annotation;
+			edit = AnnotatedTextEdit.insert(position, newText, annotation);
+		} else {
+			this.assertChangeAnnotations(this.changeAnnotations);
+			id = this.changeAnnotations.manage(annotation);
+			edit = AnnotatedTextEdit.insert(position, newText, id);
+		}
+		this.edits.push(edit);
+		if (id !== undefined) {
+			return id;
+		}
+	}
+	replace(range, newText, annotation) {
+		let edit;
+		let id;
+		if (annotation === undefined) {
+			edit = TextEdit.replace(range, newText);
+		} else if (ChangeAnnotationIdentifier.is(annotation)) {
+			id = annotation;
+			edit = AnnotatedTextEdit.replace(range, newText, annotation);
+		} else {
+			this.assertChangeAnnotations(this.changeAnnotations);
+			id = this.changeAnnotations.manage(annotation);
+			edit = AnnotatedTextEdit.replace(range, newText, id);
+		}
+		this.edits.push(edit);
+		if (id !== undefined) {
+			return id;
+		}
+	}
+	delete(range, annotation) {
+		let edit;
+		let id;
+		if (annotation === undefined) {
+			edit = TextEdit.del(range);
+		} else if (ChangeAnnotationIdentifier.is(annotation)) {
+			id = annotation;
+			edit = AnnotatedTextEdit.del(range, annotation);
+		} else {
+			this.assertChangeAnnotations(this.changeAnnotations);
+			id = this.changeAnnotations.manage(annotation);
+			edit = AnnotatedTextEdit.del(range, id);
+		}
+		this.edits.push(edit);
+		if (id !== undefined) {
+			return id;
+		}
+	}
+	add(edit) {
+		this.edits.push(edit);
+	}
+	all() {
+		return this.edits;
+	}
+	clear() {
+		this.edits.splice(0, this.edits.length);
+	}
+	assertChangeAnnotations(value) {
+		if (value === undefined) {
+			throw new Error(`Text edit change is not configured to manage change annotations.`);
+		}
+	}
+};
+/**
+* A helper class
+*/
+var ChangeAnnotations = class {
+	constructor(annotations) {
+		this._annotations = annotations === undefined ? Object.create(null) : annotations;
+		this._counter = 0;
+		this._size = 0;
+	}
+	all() {
+		return this._annotations;
+	}
+	get size() {
+		return this._size;
+	}
+	manage(idOrAnnotation, annotation) {
+		let id;
+		if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
+			id = idOrAnnotation;
+		} else {
+			id = this.nextId();
+			annotation = idOrAnnotation;
+		}
+		if (this._annotations[id] !== undefined) {
+			throw new Error(`Id ${id} is already in use.`);
+		}
+		if (annotation === undefined) {
+			throw new Error(`No annotation provided for id ${id}`);
+		}
+		this._annotations[id] = annotation;
+		this._size++;
+		return id;
+	}
+	nextId() {
+		this._counter++;
+		return this._counter.toString();
+	}
+};
+/**
+* A workspace change helps constructing changes to a workspace.
+*/
+var WorkspaceChange = class {
+	constructor(workspaceEdit) {
+		this._textEditChanges = Object.create(null);
+		if (workspaceEdit !== undefined) {
+			this._workspaceEdit = workspaceEdit;
+			if (workspaceEdit.documentChanges) {
+				this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);
+				workspaceEdit.changeAnnotations = this._changeAnnotations.all();
+				workspaceEdit.documentChanges.forEach((change) => {
+					if (TextDocumentEdit.is(change)) {
+						const textEditChange = new TextEditChangeImpl(change.edits, this._changeAnnotations);
+						this._textEditChanges[change.textDocument.uri] = textEditChange;
+					}
+				});
+			} else if (workspaceEdit.changes) {
+				Object.keys(workspaceEdit.changes).forEach((key) => {
+					const textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);
+					this._textEditChanges[key] = textEditChange;
+				});
+			}
+		} else {
+			this._workspaceEdit = {};
+		}
+	}
+	/**
+	* Returns the underlying {@link WorkspaceEdit} literal
+	* use to be returned from a workspace edit operation like rename.
+	*/
+	get edit() {
+		this.initDocumentChanges();
+		if (this._changeAnnotations !== undefined) {
+			if (this._changeAnnotations.size === 0) {
+				this._workspaceEdit.changeAnnotations = undefined;
+			} else {
+				this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
+			}
+		}
+		return this._workspaceEdit;
+	}
+	getTextEditChange(key) {
+		if (OptionalVersionedTextDocumentIdentifier.is(key)) {
+			this.initDocumentChanges();
+			if (this._workspaceEdit.documentChanges === undefined) {
+				throw new Error("Workspace edit is not configured for document changes.");
+			}
+			const textDocument = {
+				uri: key.uri,
+				version: key.version
+			};
+			let result = this._textEditChanges[textDocument.uri];
+			if (!result) {
+				const edits = [];
+				const textDocumentEdit = {
+					textDocument,
+					edits
+				};
+				this._workspaceEdit.documentChanges.push(textDocumentEdit);
+				result = new TextEditChangeImpl(edits, this._changeAnnotations);
+				this._textEditChanges[textDocument.uri] = result;
+			}
+			return result;
+		} else {
+			this.initChanges();
+			if (this._workspaceEdit.changes === undefined) {
+				throw new Error("Workspace edit is not configured for normal text edit changes.");
+			}
+			let result = this._textEditChanges[key];
+			if (!result) {
+				let edits = [];
+				this._workspaceEdit.changes[key] = edits;
+				result = new TextEditChangeImpl(edits);
+				this._textEditChanges[key] = result;
+			}
+			return result;
+		}
+	}
+	initDocumentChanges() {
+		if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {
+			this._changeAnnotations = new ChangeAnnotations();
+			this._workspaceEdit.documentChanges = [];
+			this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
+		}
+	}
+	initChanges() {
+		if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {
+			this._workspaceEdit.changes = Object.create(null);
+		}
+	}
+	createFile(uri, optionsOrAnnotation, options) {
+		this.initDocumentChanges();
+		if (this._workspaceEdit.documentChanges === undefined) {
+			throw new Error("Workspace edit is not configured for document changes.");
+		}
+		let annotation;
+		if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
+			annotation = optionsOrAnnotation;
+		} else {
+			options = optionsOrAnnotation;
+		}
+		let operation;
+		let id;
+		if (annotation === undefined) {
+			operation = CreateFile.create(uri, options);
+		} else {
+			id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
+			operation = CreateFile.create(uri, options, id);
+		}
+		this._workspaceEdit.documentChanges.push(operation);
+		if (id !== undefined) {
+			return id;
+		}
+	}
+	renameFile(oldUri, newUri, optionsOrAnnotation, options) {
+		this.initDocumentChanges();
+		if (this._workspaceEdit.documentChanges === undefined) {
+			throw new Error("Workspace edit is not configured for document changes.");
+		}
+		let annotation;
+		if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
+			annotation = optionsOrAnnotation;
+		} else {
+			options = optionsOrAnnotation;
+		}
+		let operation;
+		let id;
+		if (annotation === undefined) {
+			operation = RenameFile.create(oldUri, newUri, options);
+		} else {
+			id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
+			operation = RenameFile.create(oldUri, newUri, options, id);
+		}
+		this._workspaceEdit.documentChanges.push(operation);
+		if (id !== undefined) {
+			return id;
+		}
+	}
+	deleteFile(uri, optionsOrAnnotation, options) {
+		this.initDocumentChanges();
+		if (this._workspaceEdit.documentChanges === undefined) {
+			throw new Error("Workspace edit is not configured for document changes.");
+		}
+		let annotation;
+		if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
+			annotation = optionsOrAnnotation;
+		} else {
+			options = optionsOrAnnotation;
+		}
+		let operation;
+		let id;
+		if (annotation === undefined) {
+			operation = DeleteFile.create(uri, options);
+		} else {
+			id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
+			operation = DeleteFile.create(uri, options, id);
+		}
+		this._workspaceEdit.documentChanges.push(operation);
+		if (id !== undefined) {
+			return id;
+		}
+	}
+};
+/**
+* The TextDocumentIdentifier namespace provides helper functions to work with
+* {@link TextDocumentIdentifier} literals.
+*/
+var TextDocumentIdentifier;
+(function(TextDocumentIdentifier$1) {
+	/**
+	* Creates a new TextDocumentIdentifier literal.
+	* @param uri The document's uri.
+	*/
+	function create(uri) {
+		return { uri };
+	}
+	TextDocumentIdentifier$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link TextDocumentIdentifier} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Is.string(candidate.uri);
+	}
+	TextDocumentIdentifier$1.is = is;
+})(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
+/**
+* The VersionedTextDocumentIdentifier namespace provides helper functions to work with
+* {@link VersionedTextDocumentIdentifier} literals.
+*/
+var VersionedTextDocumentIdentifier;
+(function(VersionedTextDocumentIdentifier$1) {
+	/**
+	* Creates a new VersionedTextDocumentIdentifier literal.
+	* @param uri The document's uri.
+	* @param version The document's version.
+	*/
+	function create(uri, version) {
+		return {
+			uri,
+			version
+		};
+	}
+	VersionedTextDocumentIdentifier$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link VersionedTextDocumentIdentifier} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
+	}
+	VersionedTextDocumentIdentifier$1.is = is;
+})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
+/**
+* The OptionalVersionedTextDocumentIdentifier namespace provides helper functions to work with
+* {@link OptionalVersionedTextDocumentIdentifier} literals.
+*/
+var OptionalVersionedTextDocumentIdentifier;
+(function(OptionalVersionedTextDocumentIdentifier$1) {
+	/**
+	* Creates a new OptionalVersionedTextDocumentIdentifier literal.
+	* @param uri The document's uri.
+	* @param version The document's version.
+	*/
+	function create(uri, version) {
+		return {
+			uri,
+			version
+		};
+	}
+	OptionalVersionedTextDocumentIdentifier$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link OptionalVersionedTextDocumentIdentifier} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
+	}
+	OptionalVersionedTextDocumentIdentifier$1.is = is;
+})(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
+/**
+* The TextDocumentItem namespace provides helper functions to work with
+* {@link TextDocumentItem} literals.
+*/
+var TextDocumentItem;
+(function(TextDocumentItem$1) {
+	/**
+	* Creates a new TextDocumentItem literal.
+	* @param uri The document's uri.
+	* @param languageId The document's language identifier.
+	* @param version The document's version number.
+	* @param text The document's text.
+	*/
+	function create(uri, languageId, version, text) {
+		return {
+			uri,
+			languageId,
+			version,
+			text
+		};
+	}
+	TextDocumentItem$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link TextDocumentItem} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
+	}
+	TextDocumentItem$1.is = is;
+})(TextDocumentItem || (TextDocumentItem = {}));
+/**
+* Describes the content type that a client supports in various
+* result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
+*
+* Please note that `MarkupKinds` must not start with a `$`. This kinds
+* are reserved for internal usage.
+*/
+var MarkupKind;
+(function(MarkupKind$1) {
+	/**
+	* Plain text is supported as a content format
+	*/
+	MarkupKind$1.PlainText = "plaintext";
+	/**
+	* Markdown is supported as a content format
+	*/
+	MarkupKind$1.Markdown = "markdown";
+	/**
+	* Checks whether the given value is a value of the {@link MarkupKind} type.
+	*/
+	function is(value) {
+		const candidate = value;
+		return candidate === MarkupKind$1.PlainText || candidate === MarkupKind$1.Markdown;
+	}
+	MarkupKind$1.is = is;
+})(MarkupKind || (MarkupKind = {}));
+var MarkupContent;
+(function(MarkupContent$1) {
+	/**
+	* Checks whether the given value conforms to the {@link MarkupContent} interface.
+	*/
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
+	}
+	MarkupContent$1.is = is;
+})(MarkupContent || (MarkupContent = {}));
+/**
+* The kind of a completion entry.
+*/
+var CompletionItemKind;
+(function(CompletionItemKind$1) {
+	CompletionItemKind$1.Text = 1;
+	CompletionItemKind$1.Method = 2;
+	CompletionItemKind$1.Function = 3;
+	CompletionItemKind$1.Constructor = 4;
+	CompletionItemKind$1.Field = 5;
+	CompletionItemKind$1.Variable = 6;
+	CompletionItemKind$1.Class = 7;
+	CompletionItemKind$1.Interface = 8;
+	CompletionItemKind$1.Module = 9;
+	CompletionItemKind$1.Property = 10;
+	CompletionItemKind$1.Unit = 11;
+	CompletionItemKind$1.Value = 12;
+	CompletionItemKind$1.Enum = 13;
+	CompletionItemKind$1.Keyword = 14;
+	CompletionItemKind$1.Snippet = 15;
+	CompletionItemKind$1.Color = 16;
+	CompletionItemKind$1.File = 17;
+	CompletionItemKind$1.Reference = 18;
+	CompletionItemKind$1.Folder = 19;
+	CompletionItemKind$1.EnumMember = 20;
+	CompletionItemKind$1.Constant = 21;
+	CompletionItemKind$1.Struct = 22;
+	CompletionItemKind$1.Event = 23;
+	CompletionItemKind$1.Operator = 24;
+	CompletionItemKind$1.TypeParameter = 25;
+})(CompletionItemKind || (CompletionItemKind = {}));
+/**
+* Defines whether the insert text in a completion item should be interpreted as
+* plain text or a snippet.
+*/
+var InsertTextFormat;
+(function(InsertTextFormat$1) {
+	/**
+	* The primary text to be inserted is treated as a plain string.
+	*/
+	InsertTextFormat$1.PlainText = 1;
+	/**
+	* The primary text to be inserted is treated as a snippet.
+	*
+	* A snippet can define tab stops and placeholders with `$1`, `$2`
+	* and `${3:foo}`. `$0` defines the final tab stop, it defaults to
+	* the end of the snippet. Placeholders with equal identifiers are linked,
+	* that is typing in one will update others too.
+	*
+	* See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax
+	*/
+	InsertTextFormat$1.Snippet = 2;
+})(InsertTextFormat || (InsertTextFormat = {}));
+/**
+* Completion item tags are extra annotations that tweak the rendering of a completion
+* item.
+*
+* @since 3.15.0
+*/
+var CompletionItemTag;
+(function(CompletionItemTag$1) {
+	/**
+	* Render a completion as obsolete, usually using a strike-out.
+	*/
+	CompletionItemTag$1.Deprecated = 1;
+})(CompletionItemTag || (CompletionItemTag = {}));
+/**
+* The InsertReplaceEdit namespace provides functions to deal with insert / replace edits.
+*
+* @since 3.16.0
+*/
+var InsertReplaceEdit;
+(function(InsertReplaceEdit$1) {
+	/**
+	* Creates a new insert / replace edit
+	*/
+	function create(newText, insert, replace) {
+		return {
+			newText,
+			insert,
+			replace
+		};
+	}
+	InsertReplaceEdit$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link InsertReplaceEdit} interface.
+	*/
+	function is(value) {
+		const candidate = value;
+		return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);
+	}
+	InsertReplaceEdit$1.is = is;
+})(InsertReplaceEdit || (InsertReplaceEdit = {}));
+/**
+* How whitespace and indentation is handled during completion
+* item insertion.
+*
+* @since 3.16.0
+*/
+var InsertTextMode;
+(function(InsertTextMode$1) {
+	/**
+	* The insertion or replace strings is taken as it is. If the
+	* value is multi line the lines below the cursor will be
+	* inserted using the indentation defined in the string value.
+	* The client will not apply any kind of adjustments to the
+	* string.
+	*/
+	InsertTextMode$1.asIs = 1;
+	/**
+	* The editor adjusts leading whitespace of new lines so that
+	* they match the indentation up to the cursor of the line for
+	* which the item is accepted.
+	*
+	* Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a
+	* multi line completion item is indented using 2 tabs and all
+	* following lines inserted will be indented using 2 tabs as well.
+	*/
+	InsertTextMode$1.adjustIndentation = 2;
+})(InsertTextMode || (InsertTextMode = {}));
+var CompletionItemLabelDetails;
+(function(CompletionItemLabelDetails$1) {
+	function is(value) {
+		const candidate = value;
+		return candidate && (Is.string(candidate.detail) || candidate.detail === undefined) && (Is.string(candidate.description) || candidate.description === undefined);
+	}
+	CompletionItemLabelDetails$1.is = is;
+})(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));
+/**
+* The CompletionItem namespace provides functions to deal with
+* completion items.
+*/
+var CompletionItem;
+(function(CompletionItem$1) {
+	/**
+	* Create a completion item and seed it with a label.
+	* @param label The completion item's label
+	*/
+	function create(label) {
+		return { label };
+	}
+	CompletionItem$1.create = create;
+})(CompletionItem || (CompletionItem = {}));
+/**
+* The CompletionList namespace provides functions to deal with
+* completion lists.
+*/
+var CompletionList;
+(function(CompletionList$1) {
+	/**
+	* Creates a new completion list.
+	*
+	* @param items The completion items.
+	* @param isIncomplete The list is not complete.
+	*/
+	function create(items, isIncomplete) {
+		return {
+			items: items ? items : [],
+			isIncomplete: !!isIncomplete
+		};
+	}
+	CompletionList$1.create = create;
+})(CompletionList || (CompletionList = {}));
+var MarkedString;
+(function(MarkedString$1) {
+	/**
+	* Creates a marked string from plain text.
+	*
+	* @param plainText The plain text.
+	*/
+	function fromPlainText(plainText) {
+		return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
+	}
+	MarkedString$1.fromPlainText = fromPlainText;
+	/**
+	* Checks whether the given value conforms to the {@link MarkedString} type.
+	*/
+	function is(value) {
+		const candidate = value;
+		return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
+	}
+	MarkedString$1.is = is;
+})(MarkedString || (MarkedString = {}));
+var Hover;
+(function(Hover$1) {
+	/**
+	* Checks whether the given value conforms to the {@link Hover} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === undefined || Range.is(value.range));
+	}
+	Hover$1.is = is;
+})(Hover || (Hover = {}));
+/**
+* The ParameterInformation namespace provides helper functions to work with
+* {@link ParameterInformation} literals.
+*/
+var ParameterInformation;
+(function(ParameterInformation$1) {
+	/**
+	* Creates a new parameter information literal.
+	*
+	* @param label A label string.
+	* @param documentation A doc string.
+	*/
+	function create(label, documentation) {
+		return documentation ? {
+			label,
+			documentation
+		} : { label };
+	}
+	ParameterInformation$1.create = create;
+})(ParameterInformation || (ParameterInformation = {}));
+/**
+* The SignatureInformation namespace provides helper functions to work with
+* {@link SignatureInformation} literals.
+*/
+var SignatureInformation;
+(function(SignatureInformation$1) {
+	function create(label, documentation, ...parameters) {
+		let result = { label };
+		if (Is.defined(documentation)) {
+			result.documentation = documentation;
+		}
+		if (Is.defined(parameters)) {
+			result.parameters = parameters;
+		} else {
+			result.parameters = [];
+		}
+		return result;
+	}
+	SignatureInformation$1.create = create;
+})(SignatureInformation || (SignatureInformation = {}));
+/**
+* A document highlight kind.
+*/
+var DocumentHighlightKind;
+(function(DocumentHighlightKind$1) {
+	/**
+	* A textual occurrence.
+	*/
+	DocumentHighlightKind$1.Text = 1;
+	/**
+	* Read-access of a symbol, like reading a variable.
+	*/
+	DocumentHighlightKind$1.Read = 2;
+	/**
+	* Write-access of a symbol, like writing to a variable.
+	*/
+	DocumentHighlightKind$1.Write = 3;
+})(DocumentHighlightKind || (DocumentHighlightKind = {}));
+/**
+* DocumentHighlight namespace to provide helper functions to work with
+* {@link DocumentHighlight} literals.
+*/
+var DocumentHighlight;
+(function(DocumentHighlight$1) {
+	/**
+	* Create a DocumentHighlight object.
+	* @param range The range the highlight applies to.
+	* @param kind The highlight kind
+	*/
+	function create(range, kind) {
+		let result = { range };
+		if (Is.number(kind)) {
+			result.kind = kind;
+		}
+		return result;
+	}
+	DocumentHighlight$1.create = create;
+})(DocumentHighlight || (DocumentHighlight = {}));
+/**
+* A symbol kind.
+*/
+var SymbolKind;
+(function(SymbolKind$1) {
+	SymbolKind$1.File = 1;
+	SymbolKind$1.Module = 2;
+	SymbolKind$1.Namespace = 3;
+	SymbolKind$1.Package = 4;
+	SymbolKind$1.Class = 5;
+	SymbolKind$1.Method = 6;
+	SymbolKind$1.Property = 7;
+	SymbolKind$1.Field = 8;
+	SymbolKind$1.Constructor = 9;
+	SymbolKind$1.Enum = 10;
+	SymbolKind$1.Interface = 11;
+	SymbolKind$1.Function = 12;
+	SymbolKind$1.Variable = 13;
+	SymbolKind$1.Constant = 14;
+	SymbolKind$1.String = 15;
+	SymbolKind$1.Number = 16;
+	SymbolKind$1.Boolean = 17;
+	SymbolKind$1.Array = 18;
+	SymbolKind$1.Object = 19;
+	SymbolKind$1.Key = 20;
+	SymbolKind$1.Null = 21;
+	SymbolKind$1.EnumMember = 22;
+	SymbolKind$1.Struct = 23;
+	SymbolKind$1.Event = 24;
+	SymbolKind$1.Operator = 25;
+	SymbolKind$1.TypeParameter = 26;
+})(SymbolKind || (SymbolKind = {}));
+/**
+* Symbol tags are extra annotations that tweak the rendering of a symbol.
+*
+* @since 3.16
+*/
+var SymbolTag;
+(function(SymbolTag$1) {
+	/**
+	* Render a symbol as obsolete, usually using a strike-out.
+	*/
+	SymbolTag$1.Deprecated = 1;
+})(SymbolTag || (SymbolTag = {}));
+var SymbolInformation;
+(function(SymbolInformation$1) {
+	/**
+	* Creates a new symbol information literal.
+	*
+	* @param name The name of the symbol.
+	* @param kind The kind of the symbol.
+	* @param range The range of the location of the symbol.
+	* @param uri The resource of the location of symbol.
+	* @param containerName The name of the symbol containing the symbol.
+	*/
+	function create(name, kind, range, uri, containerName) {
+		let result = {
+			name,
+			kind,
+			location: {
+				uri,
+				range
+			}
+		};
+		if (containerName) {
+			result.containerName = containerName;
+		}
+		return result;
+	}
+	SymbolInformation$1.create = create;
+})(SymbolInformation || (SymbolInformation = {}));
+var WorkspaceSymbol;
+(function(WorkspaceSymbol$1) {
+	/**
+	* Create a new workspace symbol.
+	*
+	* @param name The name of the symbol.
+	* @param kind The kind of the symbol.
+	* @param uri The resource of the location of the symbol.
+	* @param range An options range of the location.
+	* @returns A WorkspaceSymbol.
+	*/
+	function create(name, kind, uri, range) {
+		return range !== undefined ? {
+			name,
+			kind,
+			location: {
+				uri,
+				range
+			}
+		} : {
+			name,
+			kind,
+			location: { uri }
+		};
+	}
+	WorkspaceSymbol$1.create = create;
+})(WorkspaceSymbol || (WorkspaceSymbol = {}));
+var DocumentSymbol;
+(function(DocumentSymbol$1) {
+	/**
+	* Creates a new symbol information literal.
+	*
+	* @param name The name of the symbol.
+	* @param detail The detail of the symbol.
+	* @param kind The kind of the symbol.
+	* @param range The range of the symbol.
+	* @param selectionRange The selectionRange of the symbol.
+	* @param children Children of the symbol.
+	*/
+	function create(name, detail, kind, range, selectionRange, children) {
+		let result = {
+			name,
+			detail,
+			kind,
+			range,
+			selectionRange
+		};
+		if (children !== undefined) {
+			result.children = children;
+		}
+		return result;
+	}
+	DocumentSymbol$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link DocumentSymbol} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range.is(candidate.range) && Range.is(candidate.selectionRange) && (candidate.detail === undefined || Is.string(candidate.detail)) && (candidate.deprecated === undefined || Is.boolean(candidate.deprecated)) && (candidate.children === undefined || Array.isArray(candidate.children)) && (candidate.tags === undefined || Array.isArray(candidate.tags));
+	}
+	DocumentSymbol$1.is = is;
+})(DocumentSymbol || (DocumentSymbol = {}));
+/**
+* A set of predefined code action kinds
+*/
+var CodeActionKind;
+(function(CodeActionKind$1) {
+	/**
+	* Empty kind.
+	*/
+	CodeActionKind$1.Empty = "";
+	/**
+	* Base kind for quickfix actions: 'quickfix'
+	*/
+	CodeActionKind$1.QuickFix = "quickfix";
+	/**
+	* Base kind for refactoring actions: 'refactor'
+	*/
+	CodeActionKind$1.Refactor = "refactor";
+	/**
+	* Base kind for refactoring extraction actions: 'refactor.extract'
+	*
+	* Example extract actions:
+	*
+	* - Extract method
+	* - Extract function
+	* - Extract variable
+	* - Extract interface from class
+	* - ...
+	*/
+	CodeActionKind$1.RefactorExtract = "refactor.extract";
+	/**
+	* Base kind for refactoring inline actions: 'refactor.inline'
+	*
+	* Example inline actions:
+	*
+	* - Inline function
+	* - Inline variable
+	* - Inline constant
+	* - ...
+	*/
+	CodeActionKind$1.RefactorInline = "refactor.inline";
+	/**
+	* Base kind for refactoring rewrite actions: 'refactor.rewrite'
+	*
+	* Example rewrite actions:
+	*
+	* - Convert JavaScript function to class
+	* - Add or remove parameter
+	* - Encapsulate field
+	* - Make method static
+	* - Move method to base class
+	* - ...
+	*/
+	CodeActionKind$1.RefactorRewrite = "refactor.rewrite";
+	/**
+	* Base kind for source actions: `source`
+	*
+	* Source code actions apply to the entire file.
+	*/
+	CodeActionKind$1.Source = "source";
+	/**
+	* Base kind for an organize imports source action: `source.organizeImports`
+	*/
+	CodeActionKind$1.SourceOrganizeImports = "source.organizeImports";
+	/**
+	* Base kind for auto-fix source actions: `source.fixAll`.
+	*
+	* Fix all actions automatically fix errors that have a clear fix that do not require user input.
+	* They should not suppress errors or perform unsafe fixes such as generating new types or classes.
+	*
+	* @since 3.15.0
+	*/
+	CodeActionKind$1.SourceFixAll = "source.fixAll";
+})(CodeActionKind || (CodeActionKind = {}));
+/**
+* The reason why code actions were requested.
+*
+* @since 3.17.0
+*/
+var CodeActionTriggerKind;
+(function(CodeActionTriggerKind$1) {
+	/**
+	* Code actions were explicitly requested by the user or by an extension.
+	*/
+	CodeActionTriggerKind$1.Invoked = 1;
+	/**
+	* Code actions were requested automatically.
+	*
+	* This typically happens when current selection in a file changes, but can
+	* also be triggered when file content changes.
+	*/
+	CodeActionTriggerKind$1.Automatic = 2;
+})(CodeActionTriggerKind || (CodeActionTriggerKind = {}));
+/**
+* The CodeActionContext namespace provides helper functions to work with
+* {@link CodeActionContext} literals.
+*/
+var CodeActionContext;
+(function(CodeActionContext$1) {
+	/**
+	* Creates a new CodeActionContext literal.
+	*/
+	function create(diagnostics, only, triggerKind) {
+		let result = { diagnostics };
+		if (only !== undefined && only !== null) {
+			result.only = only;
+		}
+		if (triggerKind !== undefined && triggerKind !== null) {
+			result.triggerKind = triggerKind;
+		}
+		return result;
+	}
+	CodeActionContext$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link CodeActionContext} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === undefined || Is.typedArray(candidate.only, Is.string)) && (candidate.triggerKind === undefined || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
+	}
+	CodeActionContext$1.is = is;
+})(CodeActionContext || (CodeActionContext = {}));
+var CodeAction;
+(function(CodeAction$1) {
+	function create(title, kindOrCommandOrEdit, kind) {
+		let result = { title };
+		let checkKind = true;
+		if (typeof kindOrCommandOrEdit === "string") {
+			checkKind = false;
+			result.kind = kindOrCommandOrEdit;
+		} else if (Command.is(kindOrCommandOrEdit)) {
+			result.command = kindOrCommandOrEdit;
+		} else {
+			result.edit = kindOrCommandOrEdit;
+		}
+		if (checkKind && kind !== undefined) {
+			result.kind = kind;
+		}
+		return result;
+	}
+	CodeAction$1.create = create;
+	function is(value) {
+		let candidate = value;
+		return candidate && Is.string(candidate.title) && (candidate.diagnostics === undefined || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === undefined || Is.string(candidate.kind)) && (candidate.edit !== undefined || candidate.command !== undefined) && (candidate.command === undefined || Command.is(candidate.command)) && (candidate.isPreferred === undefined || Is.boolean(candidate.isPreferred)) && (candidate.edit === undefined || WorkspaceEdit.is(candidate.edit));
+	}
+	CodeAction$1.is = is;
+})(CodeAction || (CodeAction = {}));
+/**
+* The CodeLens namespace provides helper functions to work with
+* {@link CodeLens} literals.
+*/
+var CodeLens;
+(function(CodeLens$1) {
+	/**
+	* Creates a new CodeLens literal.
+	*/
+	function create(range, data) {
+		let result = { range };
+		if (Is.defined(data)) {
+			result.data = data;
+		}
+		return result;
+	}
+	CodeLens$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link CodeLens} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
+	}
+	CodeLens$1.is = is;
+})(CodeLens || (CodeLens = {}));
+/**
+* The FormattingOptions namespace provides helper functions to work with
+* {@link FormattingOptions} literals.
+*/
+var FormattingOptions;
+(function(FormattingOptions$1) {
+	/**
+	* Creates a new FormattingOptions literal.
+	*/
+	function create(tabSize, insertSpaces) {
+		return {
+			tabSize,
+			insertSpaces
+		};
+	}
+	FormattingOptions$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link FormattingOptions} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
+	}
+	FormattingOptions$1.is = is;
+})(FormattingOptions || (FormattingOptions = {}));
+/**
+* The DocumentLink namespace provides helper functions to work with
+* {@link DocumentLink} literals.
+*/
+var DocumentLink;
+(function(DocumentLink$1) {
+	/**
+	* Creates a new DocumentLink literal.
+	*/
+	function create(range, target, data) {
+		return {
+			range,
+			target,
+			data
+		};
+	}
+	DocumentLink$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link DocumentLink} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
+	}
+	DocumentLink$1.is = is;
+})(DocumentLink || (DocumentLink = {}));
+/**
+* The SelectionRange namespace provides helper function to work with
+* SelectionRange literals.
+*/
+var SelectionRange;
+(function(SelectionRange$1) {
+	/**
+	* Creates a new SelectionRange
+	* @param range the range.
+	* @param parent an optional parent.
+	*/
+	function create(range, parent) {
+		return {
+			range,
+			parent
+		};
+	}
+	SelectionRange$1.create = create;
+	function is(value) {
+		let candidate = value;
+		return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange$1.is(candidate.parent));
+	}
+	SelectionRange$1.is = is;
+})(SelectionRange || (SelectionRange = {}));
+/**
+* A set of predefined token types. This set is not fixed
+* an clients can specify additional token types via the
+* corresponding client capabilities.
+*
+* @since 3.16.0
+*/
+var SemanticTokenTypes;
+(function(SemanticTokenTypes$1) {
+	SemanticTokenTypes$1["namespace"] = "namespace";
+	/**
+	* Represents a generic type. Acts as a fallback for types which can't be mapped to
+	* a specific type like class or enum.
+	*/
+	SemanticTokenTypes$1["type"] = "type";
+	SemanticTokenTypes$1["class"] = "class";
+	SemanticTokenTypes$1["enum"] = "enum";
+	SemanticTokenTypes$1["interface"] = "interface";
+	SemanticTokenTypes$1["struct"] = "struct";
+	SemanticTokenTypes$1["typeParameter"] = "typeParameter";
+	SemanticTokenTypes$1["parameter"] = "parameter";
+	SemanticTokenTypes$1["variable"] = "variable";
+	SemanticTokenTypes$1["property"] = "property";
+	SemanticTokenTypes$1["enumMember"] = "enumMember";
+	SemanticTokenTypes$1["event"] = "event";
+	SemanticTokenTypes$1["function"] = "function";
+	SemanticTokenTypes$1["method"] = "method";
+	SemanticTokenTypes$1["macro"] = "macro";
+	SemanticTokenTypes$1["keyword"] = "keyword";
+	SemanticTokenTypes$1["modifier"] = "modifier";
+	SemanticTokenTypes$1["comment"] = "comment";
+	SemanticTokenTypes$1["string"] = "string";
+	SemanticTokenTypes$1["number"] = "number";
+	SemanticTokenTypes$1["regexp"] = "regexp";
+	SemanticTokenTypes$1["operator"] = "operator";
+	/**
+	* @since 3.17.0
+	*/
+	SemanticTokenTypes$1["decorator"] = "decorator";
+})(SemanticTokenTypes || (SemanticTokenTypes = {}));
+/**
+* A set of predefined token modifiers. This set is not fixed
+* an clients can specify additional token types via the
+* corresponding client capabilities.
+*
+* @since 3.16.0
+*/
+var SemanticTokenModifiers;
+(function(SemanticTokenModifiers$1) {
+	SemanticTokenModifiers$1["declaration"] = "declaration";
+	SemanticTokenModifiers$1["definition"] = "definition";
+	SemanticTokenModifiers$1["readonly"] = "readonly";
+	SemanticTokenModifiers$1["static"] = "static";
+	SemanticTokenModifiers$1["deprecated"] = "deprecated";
+	SemanticTokenModifiers$1["abstract"] = "abstract";
+	SemanticTokenModifiers$1["async"] = "async";
+	SemanticTokenModifiers$1["modification"] = "modification";
+	SemanticTokenModifiers$1["documentation"] = "documentation";
+	SemanticTokenModifiers$1["defaultLibrary"] = "defaultLibrary";
+})(SemanticTokenModifiers || (SemanticTokenModifiers = {}));
+/**
+* @since 3.16.0
+*/
+var SemanticTokens;
+(function(SemanticTokens$1) {
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && (candidate.resultId === undefined || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
+	}
+	SemanticTokens$1.is = is;
+})(SemanticTokens || (SemanticTokens = {}));
+/**
+* The InlineValueText namespace provides functions to deal with InlineValueTexts.
+*
+* @since 3.17.0
+*/
+var InlineValueText;
+(function(InlineValueText$1) {
+	/**
+	* Creates a new InlineValueText literal.
+	*/
+	function create(range, text) {
+		return {
+			range,
+			text
+		};
+	}
+	InlineValueText$1.create = create;
+	function is(value) {
+		const candidate = value;
+		return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);
+	}
+	InlineValueText$1.is = is;
+})(InlineValueText || (InlineValueText = {}));
+/**
+* The InlineValueVariableLookup namespace provides functions to deal with InlineValueVariableLookups.
+*
+* @since 3.17.0
+*/
+var InlineValueVariableLookup;
+(function(InlineValueVariableLookup$1) {
+	/**
+	* Creates a new InlineValueText literal.
+	*/
+	function create(range, variableName, caseSensitiveLookup) {
+		return {
+			range,
+			variableName,
+			caseSensitiveLookup
+		};
+	}
+	InlineValueVariableLookup$1.create = create;
+	function is(value) {
+		const candidate = value;
+		return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup) && (Is.string(candidate.variableName) || candidate.variableName === undefined);
+	}
+	InlineValueVariableLookup$1.is = is;
+})(InlineValueVariableLookup || (InlineValueVariableLookup = {}));
+/**
+* The InlineValueEvaluatableExpression namespace provides functions to deal with InlineValueEvaluatableExpression.
+*
+* @since 3.17.0
+*/
+var InlineValueEvaluatableExpression;
+(function(InlineValueEvaluatableExpression$1) {
+	/**
+	* Creates a new InlineValueEvaluatableExpression literal.
+	*/
+	function create(range, expression) {
+		return {
+			range,
+			expression
+		};
+	}
+	InlineValueEvaluatableExpression$1.create = create;
+	function is(value) {
+		const candidate = value;
+		return candidate !== undefined && candidate !== null && Range.is(candidate.range) && (Is.string(candidate.expression) || candidate.expression === undefined);
+	}
+	InlineValueEvaluatableExpression$1.is = is;
+})(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));
+/**
+* The InlineValueContext namespace provides helper functions to work with
+* {@link InlineValueContext} literals.
+*
+* @since 3.17.0
+*/
+var InlineValueContext;
+(function(InlineValueContext$1) {
+	/**
+	* Creates a new InlineValueContext literal.
+	*/
+	function create(frameId, stoppedLocation) {
+		return {
+			frameId,
+			stoppedLocation
+		};
+	}
+	InlineValueContext$1.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link InlineValueContext} interface.
+	*/
+	function is(value) {
+		const candidate = value;
+		return Is.defined(candidate) && Range.is(value.stoppedLocation);
+	}
+	InlineValueContext$1.is = is;
+})(InlineValueContext || (InlineValueContext = {}));
+/**
+* Inlay hint kinds.
+*
+* @since 3.17.0
+*/
+var InlayHintKind;
+(function(InlayHintKind$1) {
+	/**
+	* An inlay hint that for a type annotation.
+	*/
+	InlayHintKind$1.Type = 1;
+	/**
+	* An inlay hint that is for a parameter.
+	*/
+	InlayHintKind$1.Parameter = 2;
+	function is(value) {
+		return value === 1 || value === 2;
+	}
+	InlayHintKind$1.is = is;
+})(InlayHintKind || (InlayHintKind = {}));
+var InlayHintLabelPart;
+(function(InlayHintLabelPart$1) {
+	function create(value) {
+		return { value };
+	}
+	InlayHintLabelPart$1.create = create;
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.location === undefined || Location.is(candidate.location)) && (candidate.command === undefined || Command.is(candidate.command));
+	}
+	InlayHintLabelPart$1.is = is;
+})(InlayHintLabelPart || (InlayHintLabelPart = {}));
+var InlayHint;
+(function(InlayHint$1) {
+	function create(position, label, kind) {
+		const result = {
+			position,
+			label
+		};
+		if (kind !== undefined) {
+			result.kind = kind;
+		}
+		return result;
+	}
+	InlayHint$1.create = create;
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && Position.is(candidate.position) && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is)) && (candidate.kind === undefined || InlayHintKind.is(candidate.kind)) && candidate.textEdits === undefined || Is.typedArray(candidate.textEdits, TextEdit.is) && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.paddingLeft === undefined || Is.boolean(candidate.paddingLeft)) && (candidate.paddingRight === undefined || Is.boolean(candidate.paddingRight));
+	}
+	InlayHint$1.is = is;
+})(InlayHint || (InlayHint = {}));
+var StringValue;
+(function(StringValue$1) {
+	function createSnippet(value) {
+		return {
+			kind: "snippet",
+			value
+		};
+	}
+	StringValue$1.createSnippet = createSnippet;
+})(StringValue || (StringValue = {}));
+var InlineCompletionItem;
+(function(InlineCompletionItem$1) {
+	function create(insertText, filterText, range, command) {
+		return {
+			insertText,
+			filterText,
+			range,
+			command
+		};
+	}
+	InlineCompletionItem$1.create = create;
+})(InlineCompletionItem || (InlineCompletionItem = {}));
+var InlineCompletionList;
+(function(InlineCompletionList$1) {
+	function create(items) {
+		return { items };
+	}
+	InlineCompletionList$1.create = create;
+})(InlineCompletionList || (InlineCompletionList = {}));
+/**
+* Describes how an {@link InlineCompletionItemProvider inline completion provider} was triggered.
+*
+* @since 3.18.0
+* @proposed
+*/
+var InlineCompletionTriggerKind;
+(function(InlineCompletionTriggerKind$1) {
+	/**
+	* Completion was triggered explicitly by a user gesture.
+	*/
+	InlineCompletionTriggerKind$1.Invoked = 0;
+	/**
+	* Completion was triggered automatically while editing.
+	*/
+	InlineCompletionTriggerKind$1.Automatic = 1;
+})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));
+var SelectedCompletionInfo;
+(function(SelectedCompletionInfo$1) {
+	function create(range, text) {
+		return {
+			range,
+			text
+		};
+	}
+	SelectedCompletionInfo$1.create = create;
+})(SelectedCompletionInfo || (SelectedCompletionInfo = {}));
+var InlineCompletionContext;
+(function(InlineCompletionContext$1) {
+	function create(triggerKind, selectedCompletionInfo) {
+		return {
+			triggerKind,
+			selectedCompletionInfo
+		};
+	}
+	InlineCompletionContext$1.create = create;
+})(InlineCompletionContext || (InlineCompletionContext = {}));
+var WorkspaceFolder;
+(function(WorkspaceFolder$1) {
+	function is(value) {
+		const candidate = value;
+		return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);
+	}
+	WorkspaceFolder$1.is = is;
+})(WorkspaceFolder || (WorkspaceFolder = {}));
+const EOL = [
+	"\n",
+	"\r\n",
+	"\r"
+];
+/**
+* @deprecated Use the text document from the new vscode-languageserver-textdocument package.
+*/
+var TextDocument$1;
+(function(TextDocument$2) {
+	/**
+	* Creates a new ITextDocument literal from the given uri and content.
+	* @param uri The document's uri.
+	* @param languageId The document's language Id.
+	* @param version The document's version.
+	* @param content The document's content.
+	*/
+	function create(uri, languageId, version, content) {
+		return new FullTextDocument(uri, languageId, version, content);
+	}
+	TextDocument$2.create = create;
+	/**
+	* Checks whether the given literal conforms to the {@link ITextDocument} interface.
+	*/
+	function is(value) {
+		let candidate = value;
+		return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
+	}
+	TextDocument$2.is = is;
+	function applyEdits(document, edits) {
+		let text = document.getText();
+		let sortedEdits = mergeSort(edits, (a, b) => {
+			let diff = a.range.start.line - b.range.start.line;
+			if (diff === 0) {
+				return a.range.start.character - b.range.start.character;
+			}
+			return diff;
+		});
+		let lastModifiedOffset = text.length;
+		for (let i = sortedEdits.length - 1; i >= 0; i--) {
+			let e = sortedEdits[i];
+			let startOffset = document.offsetAt(e.range.start);
+			let endOffset = document.offsetAt(e.range.end);
+			if (endOffset <= lastModifiedOffset) {
+				text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
+			} else {
+				throw new Error("Overlapping edit");
+			}
+			lastModifiedOffset = startOffset;
+		}
+		return text;
+	}
+	TextDocument$2.applyEdits = applyEdits;
+	function mergeSort(data, compare) {
+		if (data.length <= 1) {
+			return data;
+		}
+		const p = data.length / 2 | 0;
+		const left = data.slice(0, p);
+		const right = data.slice(p);
+		mergeSort(left, compare);
+		mergeSort(right, compare);
+		let leftIdx = 0;
+		let rightIdx = 0;
+		let i = 0;
+		while (leftIdx < left.length && rightIdx < right.length) {
+			let ret = compare(left[leftIdx], right[rightIdx]);
+			if (ret <= 0) {
+				data[i++] = left[leftIdx++];
+			} else {
+				data[i++] = right[rightIdx++];
+			}
+		}
+		while (leftIdx < left.length) {
+			data[i++] = left[leftIdx++];
+		}
+		while (rightIdx < right.length) {
+			data[i++] = right[rightIdx++];
+		}
+		return data;
+	}
+})(TextDocument$1 || (TextDocument$1 = {}));
+/**
+* @deprecated Use the text document from the new vscode-languageserver-textdocument package.
+*/
+var FullTextDocument = class {
+	constructor(uri, languageId, version, content) {
+		this._uri = uri;
+		this._languageId = languageId;
+		this._version = version;
+		this._content = content;
+		this._lineOffsets = undefined;
+	}
+	get uri() {
+		return this._uri;
+	}
+	get languageId() {
+		return this._languageId;
+	}
+	get version() {
+		return this._version;
+	}
+	getText(range) {
+		if (range) {
+			let start = this.offsetAt(range.start);
+			let end = this.offsetAt(range.end);
+			return this._content.substring(start, end);
+		}
+		return this._content;
+	}
+	update(event, version) {
+		this._content = event.text;
+		this._version = version;
+		this._lineOffsets = undefined;
+	}
+	getLineOffsets() {
+		if (this._lineOffsets === undefined) {
+			let lineOffsets = [];
+			let text = this._content;
+			let isLineStart = true;
+			for (let i = 0; i < text.length; i++) {
+				if (isLineStart) {
+					lineOffsets.push(i);
+					isLineStart = false;
+				}
+				let ch = text.charAt(i);
+				isLineStart = ch === "\r" || ch === "\n";
+				if (ch === "\r" && i + 1 < text.length && text.charAt(i + 1) === "\n") {
+					i++;
+				}
+			}
+			if (isLineStart && text.length > 0) {
+				lineOffsets.push(text.length);
+			}
+			this._lineOffsets = lineOffsets;
+		}
+		return this._lineOffsets;
+	}
+	positionAt(offset) {
+		offset = Math.max(Math.min(offset, this._content.length), 0);
+		let lineOffsets = this.getLineOffsets();
+		let low = 0, high = lineOffsets.length;
+		if (high === 0) {
+			return Position.create(0, offset);
+		}
+		while (low < high) {
+			let mid = Math.floor((low + high) / 2);
+			if (lineOffsets[mid] > offset) {
+				high = mid;
+			} else {
+				low = mid + 1;
+			}
+		}
+		let line = low - 1;
+		return Position.create(line, offset - lineOffsets[line]);
+	}
+	offsetAt(position) {
+		let lineOffsets = this.getLineOffsets();
+		if (position.line >= lineOffsets.length) {
+			return this._content.length;
+		} else if (position.line < 0) {
+			return 0;
+		}
+		let lineOffset = lineOffsets[position.line];
+		let nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
+		return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
+	}
+	get lineCount() {
+		return this.getLineOffsets().length;
+	}
+};
+var Is;
+(function(Is$1) {
+	const toString = Object.prototype.toString;
+	function defined(value) {
+		return typeof value !== "undefined";
+	}
+	Is$1.defined = defined;
+	function undefined$1(value) {
+		return typeof value === "undefined";
+	}
+	Is$1.undefined = undefined$1;
+	function boolean(value) {
+		return value === true || value === false;
+	}
+	Is$1.boolean = boolean;
+	function string(value) {
+		return toString.call(value) === "[object String]";
+	}
+	Is$1.string = string;
+	function number(value) {
+		return toString.call(value) === "[object Number]";
+	}
+	Is$1.number = number;
+	function numberRange(value, min, max) {
+		return toString.call(value) === "[object Number]" && min <= value && value <= max;
+	}
+	Is$1.numberRange = numberRange;
+	function integer$1(value) {
+		return toString.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
+	}
+	Is$1.integer = integer$1;
+	function uinteger$1(value) {
+		return toString.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
+	}
+	Is$1.uinteger = uinteger$1;
+	function func(value) {
+		return toString.call(value) === "[object Function]";
+	}
+	Is$1.func = func;
+	function objectLiteral(value) {
+		return value !== null && typeof value === "object";
+	}
+	Is$1.objectLiteral = objectLiteral;
+	function typedArray(value, check) {
+		return Array.isArray(value) && value.every(check);
+	}
+	Is$1.typedArray = typedArray;
+})(Is || (Is = {}));
+
+//#endregion
+//#region packages/lsp/src/handlers/code-action.ts
+/** Handle a code action request for a GraphQL template. */
+const handleCodeAction = (input) => {
+	const { template, schema, tsSource, uri, selectionRange } = input;
+	if (template.kind === "fragment") {
+		return [];
+	}
+	const { preprocessed } = preprocessFragmentArgs(template.content);
+	const mapper = createPositionMapper({
+		tsSource,
+		contentStartOffset: template.contentRange.start,
+		graphqlContent: template.content
+	});
+	const gqlStart = mapper.tsToGraphql(selectionRange.start);
+	const gqlEnd = mapper.tsToGraphql(selectionRange.end);
+	if (!gqlStart || !gqlEnd) {
+		return [];
+	}
+	const preprocessedLineOffsets = computeLineOffsets(preprocessed);
+	const startOffset = positionToOffset$1(preprocessedLineOffsets, gqlStart);
+	const endOffset = positionToOffset$1(preprocessedLineOffsets, gqlEnd);
+	let ast;
+	try {
+		ast = parse(preprocessed, { noLocation: false });
+	} catch {
+		return [];
+	}
+	const typeInfo = new TypeInfo(schema);
+	const extractResult = findExtractableSelections(ast, typeInfo, startOffset, endOffset);
+	if (!extractResult) {
+		return [];
+	}
+	const { selections: matchedSelections, parentTypeName } = extractResult;
+	const firstSel = matchedSelections[0];
+	const lastSel = matchedSelections[matchedSelections.length - 1];
+	if (!firstSel?.loc || !lastSel?.loc) {
+		return [];
+	}
+	const selectedText = template.content.slice(firstSel.loc.start, lastSel.loc.end);
+	const escapedText = selectedText.replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+	const fragmentName = "ExtractedFragment";
+	const fragmentDef = `fragment ${fragmentName} on ${parentTypeName} {\n  ${escapedText.trim()}\n}`;
+	const newGqlExpr = `export const ${fragmentName} = gql.${template.schemaName}(({ fragment }) => fragment\`\n  ${fragmentDef}\n\`);\n\n`;
+	const insertionOffset = findStatementStart(tsSource, template.contentRange.start);
+	const tsLineOffsets = computeLineOffsets(tsSource);
+	const gqlLineOffsets = computeLineOffsets(preprocessed);
+	const replaceStart = mapper.graphqlToTs(offsetToPosition(gqlLineOffsets, firstSel.loc.start));
+	const replaceEnd = mapper.graphqlToTs(offsetToPosition(gqlLineOffsets, lastSel.loc.end));
+	const replaceEdit = {
+		range: {
+			start: replaceStart,
+			end: replaceEnd
+		},
+		newText: `...${fragmentName}`
+	};
+	const insertPos = offsetToPosition(tsLineOffsets, insertionOffset);
+	const insertEdit = {
+		range: {
+			start: insertPos,
+			end: insertPos
+		},
+		newText: newGqlExpr
+	};
+	return [{
+		title: `Extract Fragment "${fragmentName}"`,
+		kind: CodeActionKind.RefactorExtract,
+		edit: { changes: { [uri]: [insertEdit, replaceEdit] } }
+	}];
+};
+/** Find selections within the user's range that can be extracted into a fragment. */
+const findExtractableSelections = (ast, typeInfo, startOffset, endOffset) => {
+	let result = null;
+	visit(ast, visitWithTypeInfo(typeInfo, { SelectionSet(node) {
+		if (!node.loc || result) {
+			return;
+		}
+		const selected = node.selections.filter((sel) => {
+			if (!sel.loc) {
+				return false;
+			}
+			return sel.loc.start >= startOffset && sel.loc.end <= endOffset;
+		});
+		if (selected.length > 0) {
+			const typeName = typeInfo.getParentType()?.name;
+			if (typeName) {
+				result = {
+					selections: selected,
+					parentTypeName: typeName
+				};
+			}
+		}
+	} }));
+	return result;
+};
+/**
+* Compute brace depth at a given offset using TypeScript scanner.
+* Correctly handles strings, comments, regex, and template literals.
+*/
+const braceDepthAt = (source, offset) => {
+	const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, source);
+	let depth = 0;
+	let lastToken = ts.SyntaxKind.Unknown;
+	while (true) {
+		let token = scanner.scan();
+		if (token === ts.SyntaxKind.EndOfFileToken) break;
+		if (token === ts.SyntaxKind.SlashToken || token === ts.SyntaxKind.SlashEqualsToken) {
+			if (lastToken === ts.SyntaxKind.FirstAssignment || lastToken === ts.SyntaxKind.EqualsEqualsToken || lastToken === ts.SyntaxKind.EqualsEqualsEqualsToken || lastToken === ts.SyntaxKind.ExclamationEqualsToken || lastToken === ts.SyntaxKind.ExclamationEqualsEqualsToken || lastToken === ts.SyntaxKind.OpenParenToken || lastToken === ts.SyntaxKind.CommaToken || lastToken === ts.SyntaxKind.OpenBracketToken || lastToken === ts.SyntaxKind.ColonToken || lastToken === ts.SyntaxKind.SemicolonToken || lastToken === ts.SyntaxKind.OpenBraceToken || lastToken === ts.SyntaxKind.QuestionToken || lastToken === ts.SyntaxKind.BarBarToken || lastToken === ts.SyntaxKind.AmpersandAmpersandToken || lastToken === ts.SyntaxKind.ExclamationToken || lastToken === ts.SyntaxKind.ReturnKeyword || lastToken === ts.SyntaxKind.CaseKeyword || lastToken === ts.SyntaxKind.NewKeyword) {
+				token = scanner.reScanSlashToken();
+			}
+		}
+		const tokenStart = scanner.getTokenStart();
+		if (tokenStart >= offset) break;
+		if (token === ts.SyntaxKind.OpenBraceToken) {
+			depth++;
+		} else if (token === ts.SyntaxKind.CloseBraceToken) {
+			depth--;
+		}
+		if (token !== ts.SyntaxKind.WhitespaceTrivia && token !== ts.SyntaxKind.NewLineTrivia && token !== ts.SyntaxKind.SingleLineCommentTrivia && token !== ts.SyntaxKind.MultiLineCommentTrivia) {
+			lastToken = token;
+		}
+	}
+	return depth;
+};
+/** Find the start of the top-level statement containing the given offset. */
+const findStatementStart = (source, offset) => {
+	let pos = offset;
+	while (pos > 0 && source.charCodeAt(pos - 1) !== 10) {
+		pos--;
+	}
+	while (pos > 0) {
+		const lineStart = pos;
+		const lineText = source.slice(lineStart, source.indexOf("\n", lineStart)).trimStart();
+		const depth = braceDepthAt(source, lineStart);
+		if (depth === 0 && (lineText.startsWith("export ") || lineText.startsWith("const ") || lineText.startsWith("let ") || lineText.startsWith("var ") || lineText.startsWith("function ") || lineText.startsWith("async "))) {
+			return lineStart;
+		}
+		pos--;
+		while (pos > 0 && source.charCodeAt(pos - 1) !== 10) {
+			pos--;
+		}
+		if (depth === 0) {
+			const prevLine = source.slice(pos, lineStart - 1).trim();
+			if (prevLine.endsWith(";") || prevLine.endsWith("}")) {
+				return lineStart;
+			}
+		}
+	}
+	return pos;
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/completion.ts
+/** Handle a completion request for a GraphQL template. */
+const handleCompletion = (input) => {
+	const { template, schema, tsSource, tsPosition } = input;
+	const reconstructed = reconstructGraphql(template);
+	const headerLen = reconstructed.length - template.content.length;
+	const { preprocessed } = preprocessFragmentArgs(reconstructed);
+	const mapper = createPositionMapper({
+		tsSource,
+		contentStartOffset: template.contentRange.start,
+		graphqlContent: template.content
+	});
+	const contentPos = mapper.tsToGraphql(tsPosition);
+	if (!contentPos) {
+		return [];
+	}
+	const contentLineOffsets = computeLineOffsets(template.content);
+	const contentOffset = positionToOffset$1(contentLineOffsets, contentPos);
+	const reconstructedOffset = contentOffset + headerLen;
+	const reconstructedLineOffsets = computeLineOffsets(preprocessed);
+	const gqlPosition = offsetToPosition(reconstructedLineOffsets, reconstructedOffset);
+	const suggestions = getAutocompleteSuggestions(schema, preprocessed, toIPosition(gqlPosition), undefined, input.externalFragments);
+	return suggestions;
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/_utils.ts
+/**
+* Find the fragment spread node at the given GraphQL offset using AST.
+* Returns the FragmentSpreadNode if cursor is on a `...FragmentName` pattern.
+*/
+const findFragmentSpreadAtOffset = (preprocessed, offset) => {
+	try {
+		const ast = parse(preprocessed, { noLocation: false });
+		let found = null;
+		visit(ast, { FragmentSpread(node) {
+			if (!node.loc) {
+				return;
+			}
+			if (offset >= node.loc.start && offset < node.loc.end) {
+				found = node;
+			}
+		} });
+		return found;
+	} catch {
+		return findFragmentSpreadByText(preprocessed, offset);
+	}
+};
+/**
+* Text-based fallback: find fragment spread name at offset.
+* Handles documents with parse errors.
+*/
+const findFragmentSpreadByText = (text, offset) => {
+	const spreadPattern = /\.\.\.([A-Za-z_]\w*)/g;
+	let match = null;
+	while ((match = spreadPattern.exec(text)) !== null) {
+		const start = match.index;
+		const end = start + match[0].length;
+		if (offset >= start && offset < end) {
+			return {
+				kind: "FragmentSpread",
+				name: {
+					kind: "Name",
+					value: match[1] ?? ""
+				}
+			};
+		}
+	}
+	return null;
+};
+/**
+* Find a FragmentDefinition at a given offset.
+* Returns the name and location, or null.
+*/
+const findFragmentDefinitionAtOffset = (preprocessed, offset) => {
+	try {
+		const ast = parse(preprocessed, { noLocation: false });
+		for (const def of ast.definitions) {
+			if (def.kind === "FragmentDefinition" && def.name.loc) {
+				if (offset >= def.name.loc.start && offset < def.name.loc.end) {
+					return {
+						name: def.name.value,
+						loc: {
+							start: def.name.loc.start,
+							end: def.name.loc.end
+						}
+					};
+				}
+			}
+		}
+	} catch {}
+	return null;
+};
+/**
+* Resolve the fragment name at a given offset, checking both definitions and spreads.
+*/
+const resolveFragmentNameAtOffset = (preprocessed, offset) => {
+	const def = findFragmentDefinitionAtOffset(preprocessed, offset);
+	if (def) {
+		return def.name;
+	}
+	const spread = findFragmentSpreadAtOffset(preprocessed, offset);
+	if (spread) {
+		return spread.name.value;
+	}
+	return null;
+};
+/** Compute TS ranges for all definitions of a named fragment. */
+const computeFragmentDefinitionRanges = (fragmentName, allFragments) => {
+	const ranges = [];
+	for (const frag of allFragments) {
+		if (frag.fragmentName !== fragmentName) {
+			continue;
+		}
+		if (!frag.definition.name.loc) {
+			continue;
+		}
+		const defMapper = createPositionMapper({
+			tsSource: frag.tsSource,
+			contentStartOffset: frag.contentRange.start,
+			graphqlContent: frag.content
+		});
+		const defGqlLineOffsets = computeLineOffsets(frag.content);
+		const nameStart = offsetToPosition(defGqlLineOffsets, frag.definition.name.loc.start);
+		const nameEnd = offsetToPosition(defGqlLineOffsets, frag.definition.name.loc.end);
+		ranges.push({
+			uri: frag.uri,
+			range: {
+				start: defMapper.graphqlToTs(nameStart),
+				end: defMapper.graphqlToTs(nameEnd)
+			}
+		});
+	}
+	return ranges;
+};
+/** Compute TS ranges for all fragment spread locations. */
+const computeSpreadLocationRanges = (spreadLocations) => {
+	const ranges = [];
+	for (const loc of spreadLocations) {
+		const spreadMapper = createPositionMapper({
+			tsSource: loc.tsSource,
+			contentStartOffset: loc.template.contentRange.start,
+			graphqlContent: loc.template.content
+		});
+		const spreadGqlLineOffsets = computeLineOffsets(loc.template.content);
+		const spreadStart = offsetToPosition(spreadGqlLineOffsets, loc.nameOffset);
+		const spreadEnd = offsetToPosition(spreadGqlLineOffsets, loc.nameOffset + loc.nameLength);
+		ranges.push({
+			uri: loc.uri,
+			range: {
+				start: spreadMapper.graphqlToTs(spreadStart),
+				end: spreadMapper.graphqlToTs(spreadEnd)
+			}
+		});
+	}
+	return ranges;
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/definition.ts
+/**
+* Definition handler: provides go-to-definition for fragment spreads and schema fields/types.
+* @module
+*/
+/** Build ObjectTypeInfo[] from schema file info for graphql-language-service definition APIs. */
+const buildObjectTypeInfos = (files) => {
+	const result = [];
+	for (const file of files) {
+		const doc = parse(file.content);
+		for (const def of doc.definitions) {
+			if (isTypeDefinitionNode(def)) {
+				result.push({
+					filePath: pathToFileURL(file.filePath).href,
+					content: file.content,
+					definition: def
+				});
+			}
+		}
+	}
+	return result;
+};
+/** Handle a definition request for a GraphQL template. */
+const handleDefinition = async (input) => {
+	const { template, tsSource, tsPosition, externalFragments } = input;
+	const reconstructed = reconstructGraphql(template);
+	const headerLen = reconstructed.length - template.content.length;
+	const { preprocessed } = preprocessFragmentArgs(reconstructed);
+	const mapper = createPositionMapper({
+		tsSource,
+		contentStartOffset: template.contentRange.start,
+		graphqlContent: template.content
+	});
+	const gqlPosition = mapper.tsToGraphql(tsPosition);
+	if (!gqlPosition) {
+		return [];
+	}
+	const contentLineOffsets = computeLineOffsets(template.content);
+	const contentOffset = positionToOffset$1(contentLineOffsets, gqlPosition);
+	const reconstructedOffset = contentOffset + headerLen;
+	const fragmentSpread = findFragmentSpreadAtOffset(preprocessed, reconstructedOffset);
+	if (fragmentSpread) {
+		return resolveFragmentSpreadDefinition(preprocessed, fragmentSpread, externalFragments);
+	}
+	if (input.schema && input.schemaFiles && input.schemaFiles.length > 0) {
+		const reconstructedLineOffsets = computeLineOffsets(preprocessed);
+		const reconstructedPosition = offsetToPosition(reconstructedLineOffsets, reconstructedOffset);
+		return resolveSchemaDefinition(preprocessed, reconstructedPosition, input.schema, input.schemaFiles);
+	}
+	return [];
+};
+/** Resolve fragment spread to its definition in an external TypeScript file. */
+const resolveFragmentSpreadDefinition = async (preprocessed, fragmentSpread, externalFragments) => {
+	const fragmentInfos = externalFragments.map((f) => ({
+		filePath: f.uri,
+		content: f.content,
+		definition: f.definition
+	}));
+	try {
+		const result = await getDefinitionQueryResultForFragmentSpread(preprocessed, fragmentSpread, fragmentInfos);
+		return result.definitions.map((def) => {
+			const defPosition = toIPosition(def.position);
+			const endLine = def.range?.end?.line ?? defPosition.line;
+			const endChar = def.range?.end?.character ?? defPosition.character;
+			const targetFragment = externalFragments.find((f) => f.uri === def.path);
+			if (targetFragment) {
+				const targetReconstructedLineOffsets = computeLineOffsets(targetFragment.content);
+				const targetContentLineOffsets = computeLineOffsets(targetFragment.content.slice(targetFragment.headerLen));
+				const toOriginalPos = (pos) => {
+					const offset = positionToOffset$1(targetReconstructedLineOffsets, pos);
+					const originalOffset = Math.max(0, offset - targetFragment.headerLen);
+					return offsetToPosition(targetContentLineOffsets, originalOffset);
+				};
+				const targetMapper = createPositionMapper({
+					tsSource: targetFragment.tsSource,
+					contentStartOffset: targetFragment.contentRange.start,
+					graphqlContent: targetFragment.content.slice(targetFragment.headerLen)
+				});
+				const tsStart = targetMapper.graphqlToTs(toOriginalPos({
+					line: defPosition.line,
+					character: defPosition.character
+				}));
+				const tsEnd = targetMapper.graphqlToTs(toOriginalPos({
+					line: endLine,
+					character: endChar
+				}));
+				return {
+					uri: def.path,
+					range: {
+						start: tsStart,
+						end: tsEnd
+					}
+				};
+			}
+			return {
+				uri: def.path,
+				range: {
+					start: {
+						line: defPosition.line,
+						character: defPosition.character
+					},
+					end: {
+						line: endLine,
+						character: endChar
+					}
+				}
+			};
+		});
+	} catch {
+		return [];
+	}
+};
+/** Resolve field or type name to its definition in a schema .graphql file. */
+const resolveSchemaDefinition = (preprocessed, position, schema, schemaFiles) => {
+	const context = getContextAtPosition(preprocessed, toIPosition(position), schema);
+	if (!context) {
+		return Promise.resolve([]);
+	}
+	const { typeInfo } = context;
+	if (typeInfo.fieldDef && typeInfo.parentType) {
+		const fieldName = typeInfo.fieldDef.name;
+		const namedParentType = getNamedType(typeInfo.parentType);
+		if (!namedParentType) {
+			return Promise.resolve([]);
+		}
+		const parentTypeName = namedParentType.name;
+		const objectTypeInfos = buildObjectTypeInfos(schemaFiles);
+		return getDefinitionQueryResultForField(fieldName, parentTypeName, objectTypeInfos).then((result) => result.definitions.map((def) => ({
+			uri: def.path ?? "",
+			range: {
+				start: {
+					line: def.position.line,
+					character: def.position.character
+				},
+				end: {
+					line: def.range?.end?.line ?? def.position.line,
+					character: def.range?.end?.character ?? def.position.character
+				}
+			}
+		})));
+	}
+	return Promise.resolve([]);
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/diagnostics.ts
+/** Compute LSP diagnostics for a single GraphQL template. */
+const computeTemplateDiagnostics = (input) => {
+	const { template, schema, tsSource } = input;
+	const reconstructed = reconstructGraphql(template);
+	const headerLen = reconstructed.length - template.content.length;
+	const { preprocessed } = preprocessFragmentArgs(reconstructed);
+	const mapper = createPositionMapper({
+		tsSource,
+		contentStartOffset: template.contentRange.start,
+		graphqlContent: template.content
+	});
+	const gqlDiagnostics = getDiagnostics(preprocessed, schema, undefined, undefined, input.externalFragments);
+	const placeholderPattern = /__FRAG_SPREAD_\d+__/;
+	const reconstructedLineOffsets = computeLineOffsets(preprocessed);
+	const contentLineOffsets = computeLineOffsets(template.content);
+	const toContentPosition = (pos) => {
+		const offset = positionToOffset$1(reconstructedLineOffsets, pos);
+		const contentOffset = Math.max(0, offset - headerLen);
+		return offsetToPosition(contentLineOffsets, contentOffset);
+	};
+	return gqlDiagnostics.filter((diag) => {
+		if (placeholderPattern.test(diag.message)) {
+			return false;
+		}
+		const offset = positionToOffset$1(reconstructedLineOffsets, diag.range.start);
+		if (offset < headerLen) {
+			return false;
+		}
+		return true;
+	}).map((diag) => {
+		const startContent = toContentPosition(diag.range.start);
+		const endContent = toContentPosition(diag.range.end);
+		const startTs = mapper.graphqlToTs(startContent);
+		const endTs = mapper.graphqlToTs(endContent);
+		return {
+			range: {
+				start: {
+					line: startTs.line,
+					character: startTs.character
+				},
+				end: {
+					line: endTs.line,
+					character: endTs.character
+				}
+			},
+			message: diag.message,
+			severity: diag.severity,
+			source: "soda-gql"
+		};
+	});
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/document-symbol.ts
+/**
+* Document symbol handler: provides outline view for GraphQL templates.
+* @module
+*/
+const KIND_MAP = {
+	OperationDefinition: SymbolKind.Function,
+	FragmentDefinition: SymbolKind.Class,
+	Field: SymbolKind.Field,
+	FragmentSpread: SymbolKind.Constant,
+	InlineFragment: SymbolKind.Struct,
+	EnumValueDefinition: SymbolKind.EnumMember,
+	InputValueDefinition: SymbolKind.Property,
+	FieldDefinition: SymbolKind.Field,
+	ObjectTypeDefinition: SymbolKind.Class,
+	InputObjectTypeDefinition: SymbolKind.Class,
+	InterfaceTypeDefinition: SymbolKind.Interface,
+	EnumTypeDefinition: SymbolKind.Enum
+};
+const getSymbolName = (tree) => {
+	if (tree.representativeName) {
+		return tree.representativeName;
+	}
+	if (tree.tokenizedText) {
+		return tree.tokenizedText.map((t) => t.value).join("");
+	}
+	return tree.kind;
+};
+const convertTree = (tree, toContentPos, mapper) => {
+	const name = getSymbolName(tree);
+	const kind = KIND_MAP[tree.kind] ?? SymbolKind.Variable;
+	const startTs = mapper.graphqlToTs(toContentPos(tree.startPosition));
+	const endTs = tree.endPosition ? mapper.graphqlToTs(toContentPos(tree.endPosition)) : startTs;
+	const range = {
+		start: {
+			line: startTs.line,
+			character: startTs.character
+		},
+		end: {
+			line: endTs.line,
+			character: endTs.character
+		}
+	};
+	const children = [];
+	for (const child of tree.children) {
+		const converted = convertTree(child, toContentPos, mapper);
+		if (converted) {
+			children.push(converted);
+		}
+	}
+	return {
+		name,
+		kind,
+		range,
+		selectionRange: range,
+		children: children.length > 0 ? children : undefined
+	};
+};
+/** Handle a documentSymbol request for all GraphQL templates in a document. */
+const handleDocumentSymbol = (input) => {
+	const { templates, tsSource } = input;
+	const symbols = [];
+	for (const template of templates) {
+		const reconstructed = reconstructGraphql(template);
+		const headerLen = reconstructed.length - template.content.length;
+		const { preprocessed } = preprocessFragmentArgs(reconstructed);
+		const outline = getOutline(preprocessed);
+		if (!outline) {
+			continue;
+		}
+		const mapper = createPositionMapper({
+			tsSource,
+			contentStartOffset: template.contentRange.start,
+			graphqlContent: template.content
+		});
+		const reconstructedLineOffsets = computeLineOffsets(preprocessed);
+		const contentLineOffsets = computeLineOffsets(template.content);
+		const toContentPos = (pos) => {
+			const offset = positionToOffset$1(reconstructedLineOffsets, pos);
+			const contentOffset = Math.max(0, offset - headerLen);
+			return offsetToPosition(contentLineOffsets, contentOffset);
+		};
+		for (const tree of outline.outlineTrees) {
+			const symbol = convertTree(tree, toContentPos, mapper);
+			if (symbol) {
+				symbols.push(symbol);
+			}
+		}
+	}
+	return symbols;
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/formatting.ts
+/**
+* Formatting handler: format GraphQL content within tagged templates.
+* @module
+*/
+const defaultFormatGraphql = (source) => {
+	const ast = parse(source, { noLocation: false });
+	return print(ast);
+};
+/** Handle a document formatting request for GraphQL templates. */
+const handleFormatting = (input) => {
+	const { templates, tsSource, formatGraphql } = input;
+	const format = formatGraphql ?? defaultFormatGraphql;
+	const tsLineOffsets = computeLineOffsets(tsSource);
+	const edits = [];
+	for (const template of templates) {
+		let formatted;
+		try {
+			formatted = format(template.content);
+		} catch {
+			continue;
+		}
+		if (formatted === template.content) {
+			continue;
+		}
+		const baseIndent = detectBaseIndent(tsSource, template.contentRange.start);
+		const reindented = reindent(formatted, baseIndent, template.content);
+		if (reindented === template.content) {
+			continue;
+		}
+		const start = offsetToPosition(tsLineOffsets, template.contentRange.start);
+		const end = offsetToPosition(tsLineOffsets, template.contentRange.end);
+		edits.push({
+			range: {
+				start,
+				end
+			},
+			newText: reindented
+		});
+	}
+	return edits;
+};
+/**
+* Detect the base indentation for a template by looking at the line
+* containing the opening backtick.
+*/
+const detectBaseIndent = (tsSource, contentStartOffset) => {
+	let lineStart = contentStartOffset;
+	while (lineStart > 0 && tsSource.charCodeAt(lineStart - 1) !== 10) {
+		lineStart--;
+	}
+	let i = lineStart;
+	while (i < tsSource.length && (tsSource.charCodeAt(i) === 32 || tsSource.charCodeAt(i) === 9)) {
+		i++;
+	}
+	return tsSource.slice(lineStart, i);
+};
+/**
+* Re-indent formatted GraphQL to match the embedding context.
+*
+* The original template may start with a newline (common for multi-line templates)
+* or be inline. We match the original pattern:
+* - If original starts with newline, formatted output gets newline + indented lines
+* - If original is single-line, keep formatted as single-line if it fits
+*/
+const reindent = (formatted, baseIndent, originalContent) => {
+	const trimmedFormatted = formatted.trim();
+	if (!originalContent.includes("\n") && !trimmedFormatted.includes("\n")) {
+		return trimmedFormatted;
+	}
+	const indent = `${baseIndent}  `;
+	const lines = trimmedFormatted.split("\n");
+	const indentedLines = lines.map((line) => line.trim() === "" ? "" : indent + line);
+	const startsWithNewline = originalContent.startsWith("\n");
+	const endsWithNewline = originalContent.endsWith("\n");
+	let result = indentedLines.join("\n");
+	if (startsWithNewline) {
+		result = `\n${result}`;
+	}
+	if (endsWithNewline) {
+		result = `${result}\n${baseIndent}`;
+	}
+	return result;
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/hover.ts
+/** Handle a hover request for a GraphQL template. */
+const handleHover = (input) => {
+	const { template, schema, tsSource, tsPosition } = input;
+	const reconstructed = reconstructGraphql(template);
+	const headerLen = reconstructed.length - template.content.length;
+	const { preprocessed } = preprocessFragmentArgs(reconstructed);
+	const mapper = createPositionMapper({
+		tsSource,
+		contentStartOffset: template.contentRange.start,
+		graphqlContent: template.content
+	});
+	const contentPos = mapper.tsToGraphql(tsPosition);
+	if (!contentPos) {
+		return null;
+	}
+	const contentLineOffsets = computeLineOffsets(template.content);
+	const contentOffset = positionToOffset$1(contentLineOffsets, contentPos);
+	const reconstructedOffset = contentOffset + headerLen;
+	const reconstructedLineOffsets = computeLineOffsets(preprocessed);
+	const gqlPosition = offsetToPosition(reconstructedLineOffsets, reconstructedOffset);
+	const hoverInfo = getHoverInformation(schema, preprocessed, toIPosition(gqlPosition), undefined, { useMarkdown: true });
+	if (!hoverInfo || hoverInfo === "" || Array.isArray(hoverInfo) && hoverInfo.length === 0) {
+		return null;
+	}
+	let contents;
+	if (typeof hoverInfo === "string") {
+		contents = {
+			kind: "markdown",
+			value: hoverInfo
+		};
+	} else if (Array.isArray(hoverInfo)) {
+		const parts = hoverInfo.map((item) => typeof item === "string" ? item : item.value);
+		contents = {
+			kind: "markdown",
+			value: parts.join("\n\n")
+		};
+	} else {
+		contents = hoverInfo;
+	}
+	return { contents };
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/references.ts
+/** Handle a references request for a GraphQL template. */
+const handleReferences = (input) => {
+	const { template, tsSource, tsPosition, allFragments, findSpreadLocations } = input;
+	const { preprocessed } = preprocessFragmentArgs(template.content);
+	const mapper = createPositionMapper({
+		tsSource,
+		contentStartOffset: template.contentRange.start,
+		graphqlContent: template.content
+	});
+	const gqlPosition = mapper.tsToGraphql(tsPosition);
+	if (!gqlPosition) {
+		return [];
+	}
+	const offset = positionToOffset$1(computeLineOffsets(preprocessed), gqlPosition);
+	const fragmentName = resolveFragmentNameAtOffset(preprocessed, offset);
+	if (!fragmentName) {
+		return [];
+	}
+	const locations = [];
+	for (const r of computeFragmentDefinitionRanges(fragmentName, allFragments)) {
+		locations.push({
+			uri: r.uri,
+			range: r.range
+		});
+	}
+	for (const r of computeSpreadLocationRanges(findSpreadLocations(fragmentName))) {
+		locations.push({
+			uri: r.uri,
+			range: r.range
+		});
+	}
+	return locations;
+};
+
+//#endregion
+//#region packages/lsp/src/handlers/rename.ts
+/** Validate and return the range of the symbol to be renamed. */
+const handlePrepareRename = (input) => {
+	const { template, tsSource, tsPosition } = input;
+	const { preprocessed } = preprocessFragmentArgs(template.content);
+	const mapper = createPositionMapper({
+		tsSource,
+		contentStartOffset: template.contentRange.start,
+		graphqlContent: template.content
+	});
+	const gqlPosition = mapper.tsToGraphql(tsPosition);
+	if (!gqlPosition) {
+		return null;
+	}
+	const offset = positionToOffset$1(computeLineOffsets(preprocessed), gqlPosition);
+	const defResult = findFragmentDefinitionAtOffset(preprocessed, offset);
+	if (defResult) {
+		const gqlLineOffsets = computeLineOffsets(preprocessed);
+		const start = mapper.graphqlToTs(offsetToPosition(gqlLineOffsets, defResult.loc.start));
+		const end = mapper.graphqlToTs(offsetToPosition(gqlLineOffsets, defResult.loc.end));
+		return {
+			range: {
+				start,
+				end
+			},
+			placeholder: defResult.name
+		};
+	}
+	const spread = findFragmentSpreadAtOffset(preprocessed, offset);
+	if (spread?.name.value && spread.name.loc) {
+		const gqlLineOffsets = computeLineOffsets(preprocessed);
+		const start = mapper.graphqlToTs(offsetToPosition(gqlLineOffsets, spread.name.loc.start));
+		const end = mapper.graphqlToTs(offsetToPosition(gqlLineOffsets, spread.name.loc.end));
+		return {
+			range: {
+				start,
+				end
+			},
+			placeholder: spread.name.value
+		};
+	}
+	return null;
+};
+/** Perform a rename across the workspace. */
+const handleRename = (input) => {
+	const { template, tsSource, tsPosition, newName, allFragments, findSpreadLocations } = input;
+	const { preprocessed } = preprocessFragmentArgs(template.content);
+	const mapper = createPositionMapper({
+		tsSource,
+		contentStartOffset: template.contentRange.start,
+		graphqlContent: template.content
+	});
+	const gqlPosition = mapper.tsToGraphql(tsPosition);
+	if (!gqlPosition) {
+		return null;
+	}
+	const offset = positionToOffset$1(computeLineOffsets(preprocessed), gqlPosition);
+	const fragmentName = resolveFragmentNameAtOffset(preprocessed, offset);
+	if (!fragmentName) {
+		return null;
+	}
+	const changes = {};
+	const addEdit = (uri, range, text) => {
+		if (!changes[uri]) {
+			changes[uri] = [];
+		}
+		changes[uri].push({
+			range,
+			newText: text
+		});
+	};
+	for (const r of computeFragmentDefinitionRanges(fragmentName, allFragments)) {
+		addEdit(r.uri, r.range, newName);
+	}
+	for (const r of computeSpreadLocationRanges(findSpreadLocations(fragmentName))) {
+		addEdit(r.uri, r.range, newName);
+	}
+	if (Object.keys(changes).length === 0) {
+		return null;
+	}
+	return { changes };
+};
+
+//#endregion
+//#region packages/lsp/src/server.ts
+/**
+* LSP server: wires all components together via vscode-languageserver.
+* @module
+*/
+const createLspServer = (options) => {
+	const connection = options?.connection ?? createConnection(ProposedFeatures.all);
+	const documents = new TextDocuments(TextDocument);
+	let registry;
+	const swcNotification = { shown: false };
+	const publishDiagnosticsForDocument = (uri) => {
+		if (!registry) {
+			return;
+		}
+		const ctx = registry.resolveForUri(uri);
+		if (!ctx) {
+			connection.sendDiagnostics({
+				uri,
+				diagnostics: []
+			});
+			return;
+		}
+		const state = ctx.documentManager.get(uri);
+		if (!state) {
+			connection.sendDiagnostics({
+				uri,
+				diagnostics: []
+			});
+			return;
+		}
+		const allDiagnostics = state.templates.flatMap((template) => {
+			const entry = ctx.schemaResolver.getSchema(template.schemaName);
+			if (!entry) {
+				return [];
+			}
+			const externalFragments = ctx.documentManager.getExternalFragments(uri, template.schemaName).map((f) => f.definition);
+			return [...computeTemplateDiagnostics({
+				template,
+				schema: entry.schema,
+				tsSource: state.source,
+				externalFragments
+			})];
+		});
+		connection.sendDiagnostics({
+			uri,
+			diagnostics: allDiagnostics
+		});
+	};
+	const publishDiagnosticsForAllOpen = () => {
+		for (const doc of documents.all()) {
+			publishDiagnosticsForDocument(doc.uri);
+		}
+	};
+	connection.onInitialize((params) => {
+		const rootUri = params.rootUri ?? params.rootPath;
+		if (!rootUri) {
+			connection.window.showErrorMessage("soda-gql LSP: no workspace root provided");
+			return { capabilities: {} };
+		}
+		const rootPath = rootUri.startsWith("file://") ? fileURLToPath(rootUri) : rootUri;
+		let configPaths = findAllConfigFiles(rootPath);
+		if (configPaths.length === 0) {
+			const singleConfigPath = findConfigFile(rootPath);
+			if (!singleConfigPath) {
+				connection.window.showErrorMessage("soda-gql LSP: no config file found");
+				return { capabilities: {} };
+			}
+			configPaths = [singleConfigPath];
+		}
+		const registryResult = createConfigRegistry(configPaths);
+		if (registryResult.isErr()) {
+			connection.window.showErrorMessage(`soda-gql LSP: ${registryResult.error.message}`);
+			return { capabilities: {} };
+		}
+		registry = registryResult.value;
+		return { capabilities: {
+			textDocumentSync: TextDocumentSyncKind.Full,
+			hoverProvider: true,
+			documentSymbolProvider: true,
+			definitionProvider: true,
+			referencesProvider: true,
+			renameProvider: { prepareProvider: true },
+			documentFormattingProvider: true,
+			completionProvider: { triggerCharacters: [
+				"{",
+				"(",
+				":",
+				"@",
+				"$",
+				" ",
+				"\n",
+				"."
+			] },
+			codeActionProvider: { codeActionKinds: ["refactor.extract"] }
+		} };
+	});
+	connection.onInitialized(() => {
+		connection.client.register(DidChangeWatchedFilesNotification.type, { watchers: [{ globPattern: "**/*.graphql" }] });
+	});
+	documents.onDidChangeContent((change) => {
+		if (!registry) {
+			return;
+		}
+		const ctx = registry.resolveForUri(change.document.uri);
+		if (!ctx) {
+			return;
+		}
+		const state = ctx.documentManager.update(change.document.uri, change.document.version, change.document.getText());
+		checkSwcUnavailable(state.swcUnavailable, swcNotification, (msg) => connection.window.showErrorMessage(msg));
+		publishDiagnosticsForDocument(change.document.uri);
+	});
+	documents.onDidClose((change) => {
+		if (!registry) {
+			return;
+		}
+		const ctx = registry.resolveForUri(change.document.uri);
+		if (ctx) {
+			ctx.documentManager.remove(change.document.uri);
+		}
+		connection.sendDiagnostics({
+			uri: change.document.uri,
+			diagnostics: []
+		});
+	});
+	connection.onCompletion((params) => {
+		if (!registry) {
+			return [];
+		}
+		const ctx = registry.resolveForUri(params.textDocument.uri);
+		if (!ctx) {
+			return [];
+		}
+		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(documents.get(params.textDocument.uri)?.getText() ?? "", params.position));
+		if (!template) {
+			return [];
+		}
+		const entry = ctx.schemaResolver.getSchema(template.schemaName);
+		if (!entry) {
+			return [];
+		}
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) {
+			return [];
+		}
+		const externalFragments = ctx.documentManager.getExternalFragments(params.textDocument.uri, template.schemaName).map((f) => f.definition);
+		return handleCompletion({
+			template,
+			schema: entry.schema,
+			tsSource: doc.getText(),
+			tsPosition: {
+				line: params.position.line,
+				character: params.position.character
+			},
+			externalFragments
+		});
+	});
+	connection.onHover((params) => {
+		if (!registry) {
+			return null;
+		}
+		const ctx = registry.resolveForUri(params.textDocument.uri);
+		if (!ctx) {
+			return null;
+		}
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) {
+			return null;
+		}
+		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(doc.getText(), params.position));
+		if (!template) {
+			return null;
+		}
+		const entry = ctx.schemaResolver.getSchema(template.schemaName);
+		if (!entry) {
+			return null;
+		}
+		return handleHover({
+			template,
+			schema: entry.schema,
+			tsSource: doc.getText(),
+			tsPosition: {
+				line: params.position.line,
+				character: params.position.character
+			}
+		});
+	});
+	connection.onDefinition(async (params) => {
+		if (!registry) {
+			return [];
+		}
+		const ctx = registry.resolveForUri(params.textDocument.uri);
+		if (!ctx) {
+			return [];
+		}
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) {
+			return [];
+		}
+		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(doc.getText(), params.position));
+		if (!template) {
+			return [];
+		}
+		const externalFragments = ctx.documentManager.getExternalFragments(params.textDocument.uri, template.schemaName);
+		const entry = ctx.schemaResolver.getSchema(template.schemaName);
+		return handleDefinition({
+			template,
+			tsSource: doc.getText(),
+			tsPosition: {
+				line: params.position.line,
+				character: params.position.character
+			},
+			externalFragments,
+			schema: entry?.schema,
+			schemaFiles: entry?.files
+		});
+	});
+	connection.onReferences((params) => {
+		if (!registry) {
+			return [];
+		}
+		const ctx = registry.resolveForUri(params.textDocument.uri);
+		if (!ctx) {
+			return [];
+		}
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) {
+			return [];
+		}
+		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(doc.getText(), params.position));
+		if (!template) {
+			return [];
+		}
+		return handleReferences({
+			template,
+			tsSource: doc.getText(),
+			tsPosition: {
+				line: params.position.line,
+				character: params.position.character
+			},
+			allFragments: ctx.documentManager.getAllFragments(template.schemaName),
+			findSpreadLocations: (name) => ctx.documentManager.findFragmentSpreadLocations(name, template.schemaName)
+		});
+	});
+	connection.onPrepareRename((params) => {
+		if (!registry) {
+			return null;
+		}
+		const ctx = registry.resolveForUri(params.textDocument.uri);
+		if (!ctx) {
+			return null;
+		}
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) {
+			return null;
+		}
+		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(doc.getText(), params.position));
+		if (!template) {
+			return null;
+		}
+		return handlePrepareRename({
+			template,
+			tsSource: doc.getText(),
+			tsPosition: {
+				line: params.position.line,
+				character: params.position.character
+			}
+		});
+	});
+	connection.onRenameRequest((params) => {
+		if (!registry) {
+			return null;
+		}
+		const ctx = registry.resolveForUri(params.textDocument.uri);
+		if (!ctx) {
+			return null;
+		}
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) {
+			return null;
+		}
+		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(doc.getText(), params.position));
+		if (!template) {
+			return null;
+		}
+		return handleRename({
+			template,
+			tsSource: doc.getText(),
+			tsPosition: {
+				line: params.position.line,
+				character: params.position.character
+			},
+			newName: params.newName,
+			allFragments: ctx.documentManager.getAllFragments(template.schemaName),
+			findSpreadLocations: (name) => ctx.documentManager.findFragmentSpreadLocations(name, template.schemaName)
+		});
+	});
+	connection.onDocumentSymbol((params) => {
+		if (!registry) {
+			return [];
+		}
+		const ctx = registry.resolveForUri(params.textDocument.uri);
+		if (!ctx) {
+			return [];
+		}
+		const state = ctx.documentManager.get(params.textDocument.uri);
+		if (!state) {
+			return [];
+		}
+		return handleDocumentSymbol({
+			templates: state.templates,
+			tsSource: state.source
+		});
+	});
+	connection.onDocumentFormatting((params) => {
+		if (!registry) {
+			return [];
+		}
+		const ctx = registry.resolveForUri(params.textDocument.uri);
+		if (!ctx) {
+			return [];
+		}
+		const state = ctx.documentManager.get(params.textDocument.uri);
+		if (!state) {
+			return [];
+		}
+		return handleFormatting({
+			templates: state.templates,
+			tsSource: state.source
+		});
+	});
+	connection.onCodeAction((params) => {
+		if (!registry) {
+			return [];
+		}
+		const ctx = registry.resolveForUri(params.textDocument.uri);
+		if (!ctx) {
+			return [];
+		}
+		const doc = documents.get(params.textDocument.uri);
+		if (!doc) {
+			return [];
+		}
+		const template = ctx.documentManager.findTemplateAtOffset(params.textDocument.uri, positionToOffset(doc.getText(), params.range.start));
+		if (!template) {
+			return [];
+		}
+		const entry = ctx.schemaResolver.getSchema(template.schemaName);
+		if (!entry) {
+			return [];
+		}
+		return handleCodeAction({
+			template,
+			schema: entry.schema,
+			tsSource: doc.getText(),
+			uri: params.textDocument.uri,
+			selectionRange: {
+				start: {
+					line: params.range.start.line,
+					character: params.range.start.character
+				},
+				end: {
+					line: params.range.end.line,
+					character: params.range.end.character
+				}
+			}
+		});
+	});
+	connection.onDidChangeWatchedFiles((_params) => {
+		if (!registry) {
+			return;
+		}
+		const graphqlChanged = _params.changes.some((change) => change.uri.endsWith(".graphql") && (change.type === FileChangeType.Changed || change.type === FileChangeType.Created));
+		if (graphqlChanged) {
+			const result = registry.reloadAllSchemas();
+			publishDiagnosticsForAllOpen();
+			if (result.isErr()) {
+				for (const error of result.error) {
+					connection.window.showErrorMessage(`soda-gql LSP: schema reload failed: ${error.message}`);
+				}
+			}
+		}
+	});
+	documents.listen(connection);
+	return { start: () => {
+		connection.listen();
+	} };
+};
+/** Check if SWC is unavailable and show a one-time error notification. */
+const checkSwcUnavailable = (swcUnavailable, state, showError) => {
+	if (swcUnavailable && !state.shown) {
+		state.shown = true;
+		showError(`soda-gql LSP: ${lspErrors.swcResolutionFailed().message}`);
+	}
+};
+/** Convert LSP Position to byte offset in source text. */
+const positionToOffset = (source, position) => {
+	let line = 0;
+	let offset = 0;
+	while (line < position.line && offset < source.length) {
+		if (source.charCodeAt(offset) === 10) {
+			line++;
+		}
+		offset++;
+	}
+	return offset + position.character;
+};
+
+//#endregion
+export { createDocumentManager as a, lspErrors as i, createSchemaResolver as n, preprocessFragmentArgs as o, createPositionMapper as r, createLspServer as t };
+//# sourceMappingURL=server-BgXl3W41.mjs.map