@singapore-editor/lsp-plugin 0.1.1

package/dist/plugin.js

@@ -0,0 +1,837 @@
+import { activeDocumentForSnapshot } from "./documentSync.js";
+import { resolveLanguageServerLaneOptions } from "./lane.js";
+import { LanguageServerDocument } from "./document.js";
+import { rangeAroundOffset } from "./sourceText.js";
+import { LANGUAGE_SERVER_COMPLETION_EDIT_FEATURE, createCompletionEditFeature } from "./completion.js";
+import { LanguageServerSet, allLanguageServerFeatures, captureWorkspaceEditOriginGuard, rankedLanguageServerLanes } from "./serverSet.js";
+import { parseWorkspaceEdit } from "./workspaceEdit.js";
+import { currentWorkspaceEditOrigin } from "./workspaceEditProvenance.js";
+import { CodeActionController } from "./codeActions.js";
+import { CompletionController } from "./completionController.js";
+import { COMPLETION_KEY_COMMANDS, SIGNATURE_HELP_KEY_COMMANDS } from "./keyCommands.js";
+import { LanguageServerCompletionSources, createLanguageServerCompletionSource } from "./completionProviders.js";
+import { CompositeDiagnosticsPresenter, DiagnosticsPresenter } from "./diagnosticsPresenter.js";
+import { FormatOnTypeController } from "./formatOnType.js";
+import { DefinitionLinkController } from "./definitionLinkController.js";
+import { createLanguageServerHoverParticipant } from "./hoverParticipant.js";
+import { signatureHelpTriggerFromTypedText } from "./signatureHelp.js";
+import { DocumentHighlightController } from "./documentHighlightController.js";
+import { SemanticTokenLayerOwner } from "./semanticTokens.js";
+import { createRenameWidgetController } from "./renameWidget.js";
+import { formattingChangesText, formattingOptions, prepareFormattingEdits } from "./formatting.js";
+import { wordRangeAtOffset } from "@singapore-editor/core/document";
+import { lspPositionToOffsetInSnapshot, offsetToLspPositionInSnapshot } from "@singapore-editor/lsp";
+import { anchoredSurfaceFollowsUpdate, isInsideEditorPopup } from "@singapore-editor/plugin-ui/anchored-surface";
+import { EDITOR_HOVER_PARTICIPANT } from "@singapore-editor/plugin-ui/hover-participant";
+import { hoverControllerFor } from "@singapore-editor/plugin-ui/hover-registry";
+//#region src/plugin.ts
+var DEFAULT_PLUGIN_NAME = "editor.lsp-plugin";
+var DEFAULT_NAMESPACE = "lsp-plugin";
+var DEFAULT_TIMING_PREFIX = "lspPlugin";
+var DEFAULT_DIAGNOSTICS_SOURCE_ID = "editor.lsp-plugin.diagnostics";
+var DEFAULT_COMPLETION_ACCEPT_TIMING_NAME = "lspPlugin.completion.accept";
+function createLanguageServerPlugin(options) {
+	if ("document" in options) return createLanguageServerSetPlugin(options);
+	return createLanguageServerSetPlugin({
+		lanes: [languageServerLaneFromPluginOptions(options)],
+		onApplyWorkspaceEdit: options.onApplyWorkspaceEdit,
+		documentSync: options.documentSync,
+		semanticTokens: options.semanticTokens ? () => options.semanticTokens : void 0,
+		onDiagnostics: options.onDiagnostics,
+		onDidNavigateDiagnostic: options.onDidNavigateDiagnostic,
+		getDiagnosticActions: options.getDiagnosticActions,
+		onDefinitionLinkHover: options.onDefinitionLinkHover,
+		onOpenDefinition: options.onOpenDefinition,
+		onOpenReferences: options.onOpenReferences,
+		onRequestError: options.onRequestError,
+		onError: options.onError
+	});
+}
+function createLanguageServerSetPlugin(options) {
+	return createResolvedLanguageServerPlugin(resolveLanguageServerSetOptions(options));
+}
+function createLanguageServerAdapterPlugin(options) {
+	return createResolvedLanguageServerPlugin(resolveAdapterOptions(options));
+}
+function createResolvedLanguageServerPlugin(resolved) {
+	return {
+		name: resolved.name,
+		activate(context) {
+			const views = new LanguageServerViews();
+			return [
+				context.registerViewContribution({ createContribution: (contributionContext) => new LanguageServerContribution(contributionContext, views, resolved) }),
+				context.registerCommandContribution({ createContribution: (contributionContext) => new LanguageServerCommandContribution(contributionContext, views, resolved.commands) }),
+				context.registerEditContribution({ createContribution: (contributionContext) => new LanguageServerCompletionEditContribution(contributionContext, resolved.completion) })
+			];
+		}
+	};
+}
+/** The views of one editor, answering its commands: the first view that acts claims the key. */
+var LanguageServerViews = class {
+	views = /* @__PURE__ */ new Set();
+	register(view) {
+		this.views.add(view);
+	}
+	unregister(view) {
+		this.views.delete(view);
+	}
+	goToDefinitionFromSelection() {
+		return this.runNavigationCommand({
+			kind: "definition",
+			openMode: "default"
+		});
+	}
+	runNavigationCommand(command) {
+		return this.some((view) => view.runNavigationCommand(command));
+	}
+	moveDiagnosticMarker(direction) {
+		return this.some((view) => view.moveDiagnosticMarker(direction));
+	}
+	formatDocument() {
+		return this.some((view) => view.formatDocument());
+	}
+	renameSymbol() {
+		return this.some((view) => view.renameSymbol());
+	}
+	applyAutoFix() {
+		return this.some((view) => view.applyAutoFix());
+	}
+	completionCommand(command) {
+		return this.some((view) => view.completionCommand(command));
+	}
+	signatureHelpCommand(command) {
+		return this.some((view) => view.signatureHelpCommand(command));
+	}
+	some(run) {
+		for (const view of this.views) if (run(view)) return true;
+		return false;
+	}
+};
+var LanguageServerCommandContribution = class {
+	commands;
+	constructor(context, views, commands) {
+		this.commands = commands.map((command) => context.registerCommand(command.id, () => command.run(views)));
+	}
+	dispose() {
+		for (const command of this.commands) command.dispose();
+	}
+};
+var LanguageServerCompletionEditContribution = class {
+	completionFeature;
+	constructor(context, options) {
+		this.completionFeature = context.registerFeature(options.editFeature, createCompletionEditFeature(context, options.acceptTimingName));
+	}
+	dispose() {
+		this.completionFeature.dispose();
+	}
+};
+var LanguageServerContribution = class {
+	context;
+	views;
+	options;
+	document;
+	lanes;
+	servers;
+	diagnostics;
+	completionSources;
+	completion;
+	definitionLink;
+	hoverParticipantRegistration;
+	/**
+	* Loaded on the first `(` or `,` typed, not at boot. The surface it shares with the hover carries
+	* a Markdown renderer and its parser, which an editor that never opens an argument list has no
+	* reason to download.
+	*/
+	signatureHelpOptions;
+	signatureHelp = null;
+	signatureHelpLoad = null;
+	typedTextRegistration;
+	documentHighlights;
+	codeActions;
+	/** Absent rather than idle when switched off, so nothing watches the typing at all. */
+	formatOnType;
+	/** Absent unless the host asked for semantic colour; see LanguageServerSemanticTokensOptions. */
+	semanticTokens = null;
+	semanticTokensOptions = null;
+	semanticTokensOwner = null;
+	rename = null;
+	renameOperation = null;
+	renameActiveDocument = null;
+	/** The symbol an open prompt is renaming, which is what the prompt has to stay beside. */
+	renamePromptRange = null;
+	viewDocument = null;
+	disposed = false;
+	constructor(context, views, options) {
+		this.context = context;
+		this.views = views;
+		this.options = options;
+		const presenter = new DiagnosticsPresenter(context, context.highlightPrefix, {
+			...options.diagnostics,
+			onDidNavigateDiagnostic: options.onDidNavigateDiagnostic,
+			onError: options.onError
+		});
+		this.diagnostics = new CompositeDiagnosticsPresenter(presenter, rankedLanguageServerLanes(options.lanes, "diagnostics").map((lane) => lane.id), options.onDiagnostics);
+		this.document = options.document ?? new LanguageServerDocument({ getSnapshot: () => context.getSnapshot() }, {
+			lanes: options.lanes,
+			documentSync: options.documentSync
+		});
+		this.lanes = this.document.lanes.map((lane) => this.createLane(lane));
+		this.servers = new LanguageServerSet(this.lanes);
+		this.completionSources = new LanguageServerCompletionSources(context, this.servers.declared("completion").map((lane) => createLanguageServerCompletionSource(lane.connection.client, () => this.servers.ready("completion").includes(lane), lane.onInteractiveReady, lane.onRequestError)));
+		this.completion = new CompletionController({
+			context,
+			completionSources: this.completionSources,
+			completionEditFeature: options.completion.editFeature,
+			completionWidgetClassNamespace: options.completion.widgetClassNamespace,
+			completionAcceptOnCommitCharacter: options.completion.acceptOnCommitCharacter,
+			getActiveDocument: () => this.activeDocument(),
+			ignorePointerTarget: isInsideEditorPopup,
+			onBeforeShow: () => {
+				hoverControllerFor(context.scrollElement)?.hide();
+				this.definitionLink.clearPointerUi();
+			},
+			onRequestSuccess: () => options.onInteractiveReady?.(),
+			onRequestError: (error) => this.handleRequestError(error)
+		});
+		this.definitionLink = new DefinitionLinkController({
+			context,
+			router: this.servers,
+			linkHighlightNameNamespace: options.hoverDefinition.linkHighlightNameNamespace,
+			navigationTimingNamePrefix: options.hoverDefinition.navigationTimingNamePrefix,
+			getActiveDocument: () => this.activeDocument(),
+			onDefinitionLinkHover: options.onDefinitionLinkHover,
+			onOpenDefinition: options.onOpenDefinition,
+			onOpenReferences: options.onOpenReferences,
+			onRequestError: (error) => this.handleRequestError(error)
+		});
+		this.hoverParticipantRegistration = context.registerProvider(EDITOR_HOVER_PARTICIPANT, { language: "*" }, createLanguageServerHoverParticipant({
+			router: this.servers,
+			requestHover: (params, requestOptions, onUpdate) => this.servers.requestHover(params, requestOptions, onUpdate),
+			getActiveDocument: () => this.activeDocument(),
+			getDiagnostics: () => this.diagnostics.diagnostics,
+			getDiagnosticActions: options.getDiagnosticActions,
+			openLocation: (target) => {
+				options.onOpenDefinition?.(target);
+			},
+			onRequestSuccess: () => options.onInteractiveReady?.(),
+			onRequestError: (error) => this.handleRequestError(error)
+		})) ?? null;
+		this.typedTextRegistration = context.onDidType((text) => this.handleTypedText(text));
+		this.signatureHelpOptions = {
+			router: this.servers,
+			context,
+			getActiveDocument: () => this.activeDocument(),
+			onRequestError: (error) => this.handleRequestError(error),
+			onRequestSuccess: () => options.onInteractiveReady?.(),
+			tooltipClassNamespace: options.hoverDefinition.tooltipClassNamespace
+		};
+		this.documentHighlights = new DocumentHighlightController({
+			router: this.servers,
+			context,
+			getActiveDocument: () => this.activeDocument(),
+			highlightName: `${context.highlightPrefix}-document-highlight`,
+			onRequestError: (error) => this.handleRequestError(error)
+		});
+		this.codeActions = new CodeActionController({
+			router: this.servers,
+			context,
+			getActiveDocument: () => this.activeDocument(),
+			getDiagnostics: () => this.diagnostics.diagnostics,
+			onRequestError: (error) => this.handleRequestError(error)
+		});
+		this.formatOnType = options.formatOnType ? new FormatOnTypeController({
+			context,
+			editFeature: options.completion.editFeature
+		}) : null;
+		this.views.register(this);
+		this.update(context.getSnapshot(), "document", null);
+	}
+	update(snapshot, kind, change) {
+		if (this.disposed) return;
+		this.updateViewDocument(snapshot, kind);
+		this.abortRenameOnDocumentDrift();
+		this.definitionLink.update(snapshot, kind);
+		if (anchoredSurfaceFollowsUpdate(kind)) this.reanchorRenamePrompt();
+		if (!this.options.document) this.document.synchronize(change ?? null, kind);
+		this.completion.update(snapshot, kind, change ?? null);
+		this.signatureHelp?.update(snapshot, kind);
+		this.documentHighlights.update(snapshot, kind);
+		this.codeActions.update(kind);
+		this.formatOnType?.update(snapshot, kind, change ?? null);
+		this.syncSemanticTokens(snapshot, kind);
+		if (kind === "tokens") this.diagnostics.updateTheme(snapshot.theme ?? null);
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.views.unregister(this);
+		this.definitionLink.dispose();
+		this.hoverParticipantRegistration?.dispose();
+		this.completion.hide();
+		for (const lane of this.lanes) lane.subscription.dispose();
+		if (!this.options.document) this.document.dispose();
+		this.diagnostics.clear();
+		this.completionSources.dispose();
+		this.completion.dispose();
+		this.typedTextRegistration?.dispose();
+		this.signatureHelpLoad?.then((controller) => controller.dispose());
+		this.documentHighlights.dispose();
+		this.codeActions.dispose();
+		this.formatOnType?.dispose();
+		this.semanticTokens?.dispose();
+		this.semanticTokensOptions?.dispose?.();
+		this.semanticTokensOptions = null;
+		this.semanticTokensOwner = null;
+		this.cancelRename();
+		this.rename?.dispose();
+	}
+	goToDefinitionFromSelection() {
+		return this.runNavigationCommand({
+			kind: "definition",
+			openMode: "default"
+		});
+	}
+	runNavigationCommand(command) {
+		return this.definitionLink.runNavigationCommand(command);
+	}
+	completionCommand(command) {
+		return this.completion.runKeyCommand(command);
+	}
+	/** Before the first `(` there is no controller, and so no hint for these to act on. */
+	signatureHelpCommand(command) {
+		return this.signatureHelp?.runKeyCommand(command) ?? false;
+	}
+	moveDiagnosticMarker(direction) {
+		return this.diagnostics.moveMarker(this.activeDocument(), direction);
+	}
+	/**
+	* Formats the whole document through the language server.
+	*
+	* Reports handled as soon as the request is on its way: the answer arrives asynchronously, and
+	* returning false would let the keystroke fall through to another binding.
+	*/
+	formatDocument() {
+		const active = this.activeDocument();
+		if (!active) return false;
+		if (!this.servers.hasReady("formatting", "textDocument/formatting")) return false;
+		this.requestFormatting(active);
+		return true;
+	}
+	/**
+	* Renames the symbol under the caret.
+	*
+	* The new name comes from the host when it supplies `onRequestRenameName`, and otherwise from the
+	* editor's own input widget, so the engine is usable standalone without dictating a dialog to an
+	* application that has one.
+	*/
+	renameSymbol() {
+		const active = this.activeDocument();
+		if (!active) return false;
+		if (!this.servers.hasReady("rename", "textDocument/rename")) return false;
+		this.cancelRename();
+		const abort = new AbortController();
+		this.renameOperation = abort;
+		this.renameActiveDocument = active;
+		this.runRename(active, abort).finally(() => this.finishRename(abort));
+		return true;
+	}
+	/** Applies the preferred quick fix the oracle already found for the caret. */
+	applyAutoFix() {
+		return this.codeActions.applyAutoFix();
+	}
+	createLane(documentLane) {
+		const options = documentLane.options;
+		const diagnostics = this.diagnostics.forLane(options.id);
+		const subscription = documentLane.attach({
+			clear: () => diagnostics.clear(),
+			render: (document, items) => diagnostics.render(document, items),
+			publishSummary: (uri, version, items, freshness) => {
+				diagnostics.publishSummary(uri, version, items, freshness);
+				this.codeActions?.diagnosticsChanged();
+			}
+		}, () => {
+			if (this.disposed) return;
+			this.completion?.hide();
+			this.syncSemanticTokens(this.context.getSnapshot(), "document");
+		});
+		return {
+			connection: documentLane.connection,
+			subscription,
+			features: options.features,
+			id: options.id,
+			onApplyWorkspaceEdit: this.options.onApplyWorkspaceEdit ?? options.onApplyWorkspaceEdit,
+			onRequestError: (method, error) => {
+				if (options.onRequestError) options.onRequestError(method, error);
+				else this.options.onRequestError?.(options.id, method, error);
+			},
+			onInteractiveReady: () => {
+				if (options.onInteractiveReady) options.onInteractiveReady();
+				else this.options.onInteractiveReady?.();
+			},
+			sync: documentLane.sync
+		};
+	}
+	/**
+	* Nothing is on screen before the controller exists, so `)` closes a signature that was never
+	* shown and loads nothing. An opening `(` or a `,` is the first keystroke that needs it.
+	*/
+	handleTypedText(text) {
+		if (this.signatureHelp) {
+			this.signatureHelp.handleTypedText(text);
+			return;
+		}
+		const trigger = signatureHelpTriggerFromTypedText(text);
+		if (!trigger || trigger.kind === "close") return;
+		this.loadSignatureHelp().then((controller) => controller.handleTypedText(text));
+	}
+	loadSignatureHelp() {
+		this.signatureHelpLoad ??= import("./signatureHelpController.js").then((module) => {
+			const controller = new module.SignatureHelpController(this.signatureHelpOptions);
+			this.signatureHelp = controller;
+			if (this.disposed) controller.dispose();
+			return controller;
+		});
+		return this.signatureHelpLoad;
+	}
+	syncSemanticTokens(snapshot, kind) {
+		const selected = this.options.semanticTokens ? this.servers.ready("semanticTokens")[0] ?? null : null;
+		const owner = this.lanes.find((lane) => lane === selected) ?? null;
+		if (owner !== this.semanticTokensOwner) this.replaceSemanticTokensOwner(owner);
+		this.semanticTokens?.update(snapshot, kind);
+	}
+	replaceSemanticTokensOwner(owner) {
+		this.semanticTokens?.dispose();
+		this.semanticTokens = null;
+		this.semanticTokensOptions?.dispose?.();
+		this.semanticTokensOptions = null;
+		this.semanticTokensOwner = owner;
+		if (!owner || !this.options.semanticTokens) return;
+		const options = this.options.semanticTokens({
+			id: owner.id,
+			connection: {
+				client: owner.connection.client,
+				workspace: owner.connection.workspace
+			}
+		});
+		this.semanticTokensOptions = options;
+		this.semanticTokens = new SemanticTokenLayerOwner(this.context, options);
+	}
+	activeDocument() {
+		return this.viewDocument;
+	}
+	updateViewDocument(snapshot, kind) {
+		if (kind === "clear") {
+			this.viewDocument = null;
+			return;
+		}
+		if (this.viewDocument?.textVersion === snapshot.textVersion && kind !== "document") return;
+		this.viewDocument = activeDocumentForSnapshot(snapshot, this.options.documentSync);
+	}
+	async runRename(active, abort) {
+		const selection = this.context.getSnapshot().selections[0];
+		if (!selection) return;
+		const offset = selection.headOffset;
+		const owner = this.servers.ready("rename", "textDocument/rename")[0];
+		if (!owner) return;
+		const prepared = await this.prepareRename(active, offset, owner, abort.signal);
+		if (!prepared) return;
+		if (!this.renameIsCurrent(active, abort)) return;
+		const { range, currentName } = prepared;
+		const anchor = this.context.getRangeClientRect(range.start, range.end);
+		if (!anchor) return;
+		try {
+			this.renamePromptRange = range;
+			let nextName;
+			try {
+				nextName = await this.promptRenameName({
+					anchor,
+					currentName,
+					signal: abort.signal
+				});
+			} finally {
+				this.renamePromptRange = null;
+			}
+			if (nextName === null || nextName === currentName) return;
+			if (!this.renameIsCurrent(active, abort)) return;
+			const guard = captureWorkspaceEditOriginGuard(owner.connection.workspace);
+			const edit = await this.servers.requestSingle(owner, "textDocument/rename", {
+				newName: nextName,
+				position: offsetToLspPositionInSnapshot(active, offset),
+				textDocument: { uri: active.uri }
+			}, { signal: abort.signal }, null);
+			if (edit === null) return;
+			if (!this.renameIsCurrent(active, abort)) return;
+			await this.dispatchRenameEdit({
+				active,
+				currentName,
+				edit,
+				guard,
+				nextName,
+				owner,
+				signal: abort.signal
+			});
+		} catch (error) {
+			this.handleRequestError(error);
+		}
+	}
+	async prepareRename(active, offset, owner, signal) {
+		const fallback = rangeAroundOffset(active, offset, wordRangeAtOffset);
+		const provider = owner.connection.client.serverCapabilities?.renameProvider;
+		if (!(typeof provider === "object" && provider.prepareProvider === true)) return renameTarget(active, fallback);
+		const result = await this.servers.requestSingle(owner, "textDocument/prepareRename", {
+			position: offsetToLspPositionInSnapshot(active, offset),
+			textDocument: { uri: active.uri }
+		}, { signal }, null);
+		if (!result) return null;
+		if ("defaultBehavior" in result) return renameTarget(active, fallback);
+		const protocolRange = "range" in result ? result.range : result;
+		const target = renameTarget(active, {
+			start: lspPositionToOffsetInSnapshot(active, protocolRange.start),
+			end: lspPositionToOffsetInSnapshot(active, protocolRange.end)
+		});
+		if (!target || !("placeholder" in result)) return target;
+		return {
+			...target,
+			currentName: result.placeholder
+		};
+	}
+	/**
+	* Keeps an open prompt beside the symbol while the view moves under it.
+	*
+	* A host that supplies its own dialog places it wherever it likes, so there is nothing here to
+	* move; a symbol that has scrolled out of the rendered rows has no rect, and the prompt is left
+	* where it was rather than thrown at the top of the page.
+	*/
+	reanchorRenamePrompt() {
+		const range = this.renamePromptRange;
+		if (!range) return;
+		const anchor = this.context.getRangeClientRect(range.start, range.end);
+		if (anchor) this.rename?.reanchor(anchor);
+	}
+	promptRenameName(prompt) {
+		if (prompt.signal.aborted) return Promise.resolve(null);
+		const host = this.options.onRequestRenameName;
+		if (host) return host(prompt);
+		return this.renameWidget().prompt(prompt);
+	}
+	/** Built on first use, so a host that supplies its own prompt never creates the element. */
+	renameWidget() {
+		if (this.rename) return this.rename;
+		this.rename = createRenameWidgetController({
+			classNamespace: this.options.hoverDefinition.tooltipClassNamespace ?? "lsp-plugin",
+			document: this.context.container.ownerDocument,
+			themeSource: this.context.scrollElement,
+			returnFocus: () => this.context.focusEditor()
+		});
+		return this.rename;
+	}
+	async dispatchRenameEdit(request) {
+		const parsed = parseWorkspaceEdit(request.edit);
+		if (!parsed.ok) {
+			this.reportLaneRequestError(request.owner, "textDocument/rename", new Error(parsed.error.reason));
+			return;
+		}
+		const origin = currentWorkspaceEditOrigin(request.guard, request.active, parsed.value);
+		if (!origin) return;
+		if (request.signal.aborted) return;
+		const apply = request.owner.onApplyWorkspaceEdit;
+		if (!apply) {
+			this.reportLaneRequestError(request.owner, "textDocument/rename", /* @__PURE__ */ new Error("Rename cannot be applied without a workspace edit host."));
+			return;
+		}
+		const result = await apply({
+			guard: request.guard,
+			label: `Rename ${request.currentName} to ${request.nextName}`,
+			logicalRevisionScope: request.owner.connection.logicalRevisionScope,
+			originUri: request.active.uri,
+			originVersion: origin.version,
+			plan: parsed.value,
+			serverId: request.owner.id,
+			signal: request.signal,
+			source: "rename"
+		});
+		if (result.status !== "failed") return;
+		this.reportLaneRequestError(request.owner, "textDocument/rename", /* @__PURE__ */ new Error(`${result.code}: ${result.message}`));
+	}
+	renameIsCurrent(active, abort) {
+		if (this.disposed) return false;
+		if (abort.signal.aborted) return false;
+		if (this.renameOperation !== abort) return false;
+		return active === this.activeDocument();
+	}
+	abortRenameOnDocumentDrift() {
+		if (!this.renameOperation) return;
+		if (this.renameActiveDocument === this.activeDocument()) return;
+		this.cancelRename();
+	}
+	cancelRename() {
+		const abort = this.renameOperation;
+		this.renameOperation = null;
+		this.renameActiveDocument = null;
+		this.renamePromptRange = null;
+		abort?.abort();
+	}
+	finishRename(abort) {
+		if (this.renameOperation !== abort) return;
+		this.renameOperation = null;
+		this.renameActiveDocument = null;
+	}
+	reportLaneRequestError(owner, method, error) {
+		if (owner.onRequestError) {
+			owner.onRequestError(method, error);
+			return;
+		}
+		this.handleRequestError(error);
+	}
+	async requestFormatting(active) {
+		try {
+			const edits = await this.servers.request("textDocument/formatting", {
+				options: formattingOptions(this.context.getSnapshot().tabSize),
+				textDocument: { uri: active.uri }
+			});
+			if (active !== this.activeDocument()) return;
+			const converted = prepareFormattingEdits(active, edits);
+			if (converted.length === 0) return;
+			if (!formattingChangesText(active.textSnapshot, converted)) return;
+			this.applyFormattingEdits(converted, active.textSnapshot.length);
+		} catch (error) {
+			this.handleRequestError(error);
+		}
+	}
+	/**
+	* Applies formatting through the same edit feature completions use, so a format is one
+	* transaction and one undo step.
+	*
+	* The caret is pinned to its offset rather than tracked through the edits: formatting moves text
+	* wholesale, and an offset that survives is closer to where the user was looking than a position
+	* mapped through a rewrite of the whole file.
+	*/
+	applyFormattingEdits(edits, previousLength) {
+		const feature = this.context.getFeature(this.options.completion.editFeature);
+		if (!feature) return;
+		const length = edits.reduce((size, edit) => size + edit.text.length - (edit.to - edit.from), previousLength);
+		const head = Math.min(this.context.getSnapshot().selections[0]?.headOffset ?? 0, length);
+		feature.applyCompletion({
+			edits,
+			selection: {
+				anchor: head,
+				head
+			}
+		});
+	}
+	handleRequestError(error) {
+		if (isAbortError(error)) return;
+		this.options.onError?.(error);
+	}
+};
+function renameTarget(document, range) {
+	if (range.end <= range.start) return null;
+	const currentName = document.textSnapshot.readRange(range.start, range.end);
+	if (currentName.length === 0) return null;
+	return {
+		currentName,
+		range
+	};
+}
+function resolveAdapterOptions(options) {
+	return {
+		name: options.name,
+		lanes: [resolvedLaneFromAdapterOptions(options)],
+		documentSync: options.documentSync ?? {},
+		diagnostics: resolveDiagnosticsOptions(options),
+		completion: resolveCompletionOptions(options),
+		formatOnType: options.formatOnType ?? true,
+		hoverDefinition: resolveHoverDefinitionOptions(options),
+		commands: options.commands ?? LANGUAGE_SERVER_COMMANDS,
+		semanticTokens: options.semanticTokens ? () => options.semanticTokens : void 0,
+		onDiagnostics: options.onDiagnostics,
+		onDidNavigateDiagnostic: options.onDidNavigateDiagnostic,
+		getDiagnosticActions: options.getDiagnosticActions,
+		onDefinitionLinkHover: options.onDefinitionLinkHover,
+		onOpenDefinition: options.onOpenDefinition,
+		onOpenReferences: options.onOpenReferences,
+		onRequestRenameName: options.onRequestRenameName,
+		onApplyWorkspaceEdit: options.onApplyWorkspaceEdit,
+		onRequestError: options.onRequestError,
+		onError: options.onError
+	};
+}
+function resolveLanguageServerSetOptions(options) {
+	return {
+		name: DEFAULT_PLUGIN_NAME,
+		document: options.document,
+		lanes: options.document ? options.document.lanes.map((lane) => lane.options) : options.lanes.map((lane) => resolveLanguageServerLaneOptions({
+			...lane,
+			onApplyWorkspaceEdit: options.onApplyWorkspaceEdit ?? lane.onApplyWorkspaceEdit,
+			onRequestError: lane.onRequestError ?? ((method, error) => options.onRequestError?.(lane.id, method, error))
+		})),
+		documentSync: options.document?.syncOptions ?? options.documentSync ?? {},
+		diagnostics: resolveDiagnosticsOptions(),
+		completion: resolveCompletionOptions(),
+		formatOnType: true,
+		hoverDefinition: resolveHoverDefinitionOptions(),
+		commands: LANGUAGE_SERVER_COMMANDS,
+		semanticTokens: options.semanticTokens,
+		onDiagnostics: options.onDiagnostics,
+		onDidNavigateDiagnostic: options.onDidNavigateDiagnostic,
+		getDiagnosticActions: options.getDiagnosticActions,
+		onInteractiveReady: options.onInteractiveReady,
+		onDefinitionLinkHover: options.onDefinitionLinkHover,
+		onOpenDefinition: options.onOpenDefinition,
+		onOpenReferences: options.onOpenReferences,
+		onApplyWorkspaceEdit: options.onApplyWorkspaceEdit,
+		onRequestError: options.onRequestError,
+		onError: options.onError
+	};
+}
+function languageServerLaneFromPluginOptions(options) {
+	return {
+		id: DEFAULT_PLUGIN_NAME,
+		features: allLanguageServerFeatures(),
+		rootUri: options.rootUri,
+		initializationOptions: options.initializationOptions,
+		timeoutMs: options.timeoutMs,
+		capabilities: options.capabilities,
+		clientInfo: options.clientInfo,
+		notificationHandlers: options.notificationHandlers,
+		serverRequestHandlers: options.serverRequestHandlers,
+		webSocketRoute: options.webSocketRoute,
+		webSocketTransportOptions: options.webSocketTransportOptions,
+		connectionProvider: options.connectionProvider,
+		onApplyWorkspaceEdit: options.onApplyWorkspaceEdit,
+		onConnectionCreated: options.onConnectionCreated,
+		onConnected: options.onConnected,
+		onStatusChange: options.onStatusChange,
+		onInteractiveReady: options.onInteractiveReady,
+		onError: options.onError
+	};
+}
+function resolvedLaneFromAdapterOptions(options) {
+	return {
+		id: options.name,
+		features: allLanguageServerFeatures(),
+		rootUri: options.rootUri,
+		initializationOptions: options.initializationOptions,
+		timeoutMs: options.timeoutMs,
+		capabilities: options.capabilities,
+		clientInfo: options.clientInfo,
+		notificationHandlers: options.notificationHandlers,
+		serverRequestHandlers: options.serverRequestHandlers,
+		createTransport: options.createTransport,
+		connectionProvider: options.connectionProvider,
+		onApplyWorkspaceEdit: options.onApplyWorkspaceEdit,
+		onConnectionCreated: options.onConnectionCreated,
+		onConnected: options.onConnected,
+		onStatusChange: options.onStatusChange,
+		onInteractiveReady: options.onInteractiveReady,
+		onRequestError: (method, error) => options.onRequestError?.(options.name, method, error),
+		onError: options.onError
+	};
+}
+function resolveDiagnosticsOptions(options) {
+	return {
+		minimapSourceId: options?.diagnostics?.minimapSourceId ?? DEFAULT_DIAGNOSTICS_SOURCE_ID,
+		highlightNameNamespace: options?.diagnostics?.highlightNameNamespace ?? DEFAULT_NAMESPACE,
+		markerTimingNamePrefix: options?.diagnostics?.markerTimingNamePrefix ?? `${DEFAULT_TIMING_PREFIX}.marker`
+	};
+}
+function resolveCompletionOptions(options) {
+	return {
+		editFeature: options?.completion?.editFeature ?? LANGUAGE_SERVER_COMPLETION_EDIT_FEATURE,
+		acceptTimingName: options?.completion?.acceptTimingName ?? DEFAULT_COMPLETION_ACCEPT_TIMING_NAME,
+		widgetClassNamespace: options?.completion?.widgetClassNamespace,
+		acceptOnCommitCharacter: options?.completion?.acceptOnCommitCharacter ?? false
+	};
+}
+function resolveHoverDefinitionOptions(options) {
+	return {
+		linkHighlightNameNamespace: options?.hoverDefinition?.linkHighlightNameNamespace ?? DEFAULT_NAMESPACE,
+		tooltipClassNamespace: options?.hoverDefinition?.tooltipClassNamespace ?? DEFAULT_NAMESPACE,
+		navigationTimingNamePrefix: options?.hoverDefinition?.navigationTimingNamePrefix ?? DEFAULT_TIMING_PREFIX
+	};
+}
+var LANGUAGE_SERVER_COMMANDS = [
+	{
+		id: "goToDefinition",
+		run: (state) => state.goToDefinitionFromSelection()
+	},
+	{
+		id: "editor.action.goToDefinition",
+		run: (state) => state.goToDefinitionFromSelection()
+	},
+	{
+		id: "editor.action.peekDefinition",
+		run: (state) => state.runNavigationCommand({
+			kind: "definition",
+			openMode: "peek"
+		})
+	},
+	{
+		id: "editor.action.revealDefinitionAside",
+		run: (state) => state.runNavigationCommand({
+			kind: "definition",
+			openMode: "aside"
+		})
+	},
+	{
+		id: "editor.action.goToImplementation",
+		run: (state) => state.runNavigationCommand({
+			kind: "implementation",
+			openMode: "default"
+		})
+	},
+	{
+		id: "editor.action.goToTypeDefinition",
+		run: (state) => state.runNavigationCommand({
+			kind: "typeDefinition",
+			openMode: "default"
+		})
+	},
+	{
+		id: "editor.action.goToReferences",
+		run: (state) => state.runNavigationCommand({
+			kind: "references",
+			openMode: "peek",
+			includeDeclaration: true
+		})
+	},
+	{
+		id: "editor.action.rename",
+		run: (state) => state.renameSymbol()
+	},
+	{
+		id: "editor.action.formatDocument",
+		run: (state) => state.formatDocument()
+	},
+	{
+		id: "editor.action.autoFix",
+		run: (state) => state.applyAutoFix()
+	},
+	{
+		id: "editor.action.marker.next",
+		run: (state) => state.moveDiagnosticMarker("next")
+	},
+	{
+		id: "editor.action.marker.prev",
+		run: (state) => state.moveDiagnosticMarker("previous")
+	},
+	...keyCommandSpecs(COMPLETION_KEY_COMMANDS, (target, command) => target.completionCommand(command)),
+	...keyCommandSpecs(SIGNATURE_HELP_KEY_COMMANDS, (target, command) => target.signatureHelpCommand(command))
+];
+/** The completion list and signature hint, driven by the keymap rather than by raw keys. */
+function keyCommandSpecs(ids, run) {
+	return Object.keys(ids).map((command) => ({
+		id: ids[command],
+		run: (target) => run(target, command)
+	}));
+}
+function isAbortError(error) {
+	if (error instanceof DOMException && error.name === "AbortError") return true;
+	if (!isRecord(error)) return false;
+	return error.name === "LspRequestCancelledError";
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+export { createLanguageServerAdapterPlugin, createLanguageServerPlugin, createLanguageServerSetPlugin };
+
+//# sourceMappingURL=plugin.js.map