@lapis-notes/api 0.1.0

package/dist/index.js

@@ -0,0 +1,87 @@
+import "./enhance";
+export * from "./editor.svelte";
+export * from "./events";
+export * from "./components/editor/extensions/autocomplete";
+export * from "./components/editor/extensions/lint";
+export * from "./components/editor/language-service";
+export * from "./menu.svelte";
+export * from "./cache.svelte";
+export * from "./plugin";
+export * from "./plugin-capability-facade";
+export * from "./plugin-asset-server";
+export * from "./plugin-dependency-resolver";
+export * from "./plugin-dependency-scanner";
+export * from "./plugin-distribution";
+export * from "./plugin-install-progress";
+export * from "./lapis-extension";
+export * from "./plugin-runtime-entry";
+export * from "./plugin-manager";
+export * from "./settings.svelte";
+export * from "./view.svelte";
+export * from "./source-text-file-view";
+export * from "./workspace.svelte";
+export * from "./hooks";
+export * from "./context.svelte";
+export * from "./application-compatibility";
+export * from "./application-state.svelte";
+export * from "./workspace-trust";
+export * from "./context-keys.svelte";
+export * from "./icons/index";
+export * from "./storage/fs";
+export * from "./storage/memory-vault-adapter";
+export * from "./storage/blob-store";
+export * from "./storage/app-database";
+export * from "./storage/task-projection";
+export * from "./storage/index-projection";
+export * from "./storage/turso-app-database";
+export * from "./storage/search-embedding-provider";
+export * from "./storage/keyval";
+export * from "./storage/path";
+export { Vault, ENOTDIR } from "./storage/vault.svelte";
+export * from "./storage/vault-state";
+export * from "./storage/native-vault-bootstrap-kv";
+export * from "./storage/vault-session";
+export * from "./storage/desktop-native";
+export * from "./storage/browser";
+export * from "./storage/browser-coordinated-app-database";
+export * from "./command.svelte";
+export * from "./configuration.svelte";
+export * from "./configuration-option-source-registry";
+export * from "./configuration-option-source-providers";
+export * from "./editor-view-registry";
+export * from "./glob";
+export * from "./platform";
+export * from "./suggest";
+export * from "./markdown";
+export * from "./markdown-extension-registry";
+export * from "./markdown-file-surface-registry";
+export * from "./logging";
+export * from "./telemetry";
+export * from "./notifications";
+export * from "./status-bar.svelte";
+export * from "./app-url";
+export * from "./agent-tools";
+export * from "./agent-skills";
+export * from "./agent-result-views";
+export * from "./language-service";
+export * from "./diagnostics";
+export * from "./metadata.svelte";
+export * from "./metadata-value";
+export * from "./embed-registry";
+export * from "./file-manager";
+export * from "./links";
+export * from "./localization-manager.svelte";
+export * from "./utils";
+export { debounce } from "./utils";
+export * from "./promise-worker";
+export * from "./search";
+export * from "./search-query";
+export * from "./search-document-provider";
+export * from "./daily-document-provider";
+export * from "./loaders";
+export * from "./bases";
+export * from "./open-file";
+export * from "./popover";
+export * from "./prompt-confirm";
+export * from "./compat";
+export * from "./tasks";

package/dist/language-service/index.d.ts

@@ -0,0 +1,9 @@
+export { LanguageServiceManager } from "./manager";
+export { createVirtualDocument, languageServicePositionToOffset, languageServiceRangeToOffsets, offsetToLanguageServicePosition, offsetsToLanguageServiceRange, } from "./virtual-document";
+export { LanguageServiceWorkerClient } from "./worker-provider";
+export type * from "./types";
+export type * from "./worker-protocol";
+export * from "./manager";
+export * from "./types";
+export * from "./virtual-document";
+export * from "./worker-protocol";

package/dist/language-service/index.js

@@ -0,0 +1,7 @@
+export { LanguageServiceManager } from "./manager";
+export { createVirtualDocument, languageServicePositionToOffset, languageServiceRangeToOffsets, offsetToLanguageServicePosition, offsetsToLanguageServiceRange, } from "./virtual-document";
+export { LanguageServiceWorkerClient } from "./worker-provider";
+export * from "./manager";
+export * from "./types";
+export * from "./virtual-document";
+export * from "./worker-protocol";

package/dist/language-service/manager.d.ts

@@ -0,0 +1,47 @@
+import type { LanguageServiceCodeAction, LanguageServiceCodeActionCommand, LanguageServiceCompletionList, LanguageServiceDiagnostic, LanguageServiceGlobalDeclaration, LanguageServiceHover, LanguageServiceLocation, LanguageServicePosition, LanguageServiceProvider, LanguageServiceRange, VirtualDocument } from "./types";
+import type { DiagnosticCollection, WorkspaceDiagnosticEntry, WorkspaceDiagnostic } from "../diagnostics";
+import type { Menu } from "../menu.svelte";
+export interface LanguageServiceDiagnosticsBinding {
+    collection: DiagnosticCollection;
+    applyCodeAction: (document: VirtualDocument, action: LanguageServiceCodeAction) => Promise<void> | void;
+}
+export declare class LanguageServiceManager {
+    private readonly providers;
+    private readonly documents;
+    private readonly globals;
+    private readonly onBeforeResolve?;
+    private diagnosticsBinding;
+    private readonly openDocuments;
+    private readonly cachedCodeActions;
+    private readonly providerFailures;
+    constructor(options?: {
+        onBeforeResolve?: (languageId: string) => Promise<void> | void;
+    });
+    registerProvider(provider: LanguageServiceProvider): () => void;
+    bindDiagnostics(binding: LanguageServiceDiagnosticsBinding): () => void;
+    reportProviderFailure(id: string, error: unknown): void;
+    clearProviderFailure(id: string): void;
+    unbindDiagnostics(): void;
+    retainDocument(uri: string): () => void;
+    buildDiagnosticItemMenu(menu: Menu, entry: WorkspaceDiagnosticEntry): void;
+    registerGlobalDeclaration(declaration: LanguageServiceGlobalDeclaration): () => void;
+    updateDocument(document: VirtualDocument): void;
+    getDocument(uri: string): VirtualDocument | null;
+    getGlobalDeclarations(): LanguageServiceGlobalDeclaration[];
+    diagnostics(document: VirtualDocument): Promise<LanguageServiceDiagnostic[]>;
+    completions(document: VirtualDocument, position: LanguageServicePosition): Promise<LanguageServiceCompletionList | null>;
+    hover(document: VirtualDocument, position: LanguageServicePosition): Promise<LanguageServiceHover | null>;
+    definition(document: VirtualDocument, position: LanguageServicePosition): Promise<LanguageServiceLocation[]>;
+    applyCommand(document: VirtualDocument, command: LanguageServiceCodeActionCommand): Promise<void>;
+    codeActions(document: VirtualDocument, range: LanguageServiceRange, skipProviderIds?: ReadonlySet<string>): Promise<LanguageServiceCodeAction[]>;
+    cachedCodeActionsFor(uri: string, diagnostic: Pick<WorkspaceDiagnostic, "message" | "range" | "code">): readonly LanguageServiceCodeAction[];
+    private context;
+    private matchingProviders;
+    private providersFor;
+    private publishDiagnostics;
+    private cacheCodeActions;
+    private deleteCachedCodeActions;
+    private settleProviderCapability;
+    private publishProviderFailures;
+    private clearPublishedDiagnostics;
+}

package/dist/language-service/manager.js

@@ -0,0 +1,404 @@
+import { markdownlintRuleUrl } from "../components/editor/extensions/lint/lapis-lint-diagnostic-helpers";
+const PROVIDER_REQUEST_TIMEOUT_MS = 8_000;
+const PROVIDER_TIMEOUT_MESSAGE = "did not complete";
+async function settleProviderRequest(request, fallback) {
+    let timeoutId;
+    try {
+        return await Promise.race([
+            Promise.resolve(request).then((value) => ({
+                status: "ok",
+                value: value ?? fallback,
+            })),
+            new Promise((resolve) => {
+                timeoutId = setTimeout(() => resolve({ status: "timeout" }), PROVIDER_REQUEST_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+function providerFailureMessage(id, error) {
+    const reason = error instanceof Error ? error.message : error ? String(error) : "";
+    if (reason === PROVIDER_TIMEOUT_MESSAGE) {
+        return `Language diagnostics provider “${id}” did not complete`;
+    }
+    return reason
+        ? `Language diagnostics provider “${id}” failed: ${reason}`
+        : `Language diagnostics provider “${id}” failed`;
+}
+export class LanguageServiceManager {
+    providers = new Map();
+    documents = new Map();
+    globals = new Map();
+    onBeforeResolve;
+    diagnosticsBinding = null;
+    openDocuments = new Map();
+    cachedCodeActions = new Map();
+    providerFailures = new Map();
+    constructor(options = {}) {
+        this.onBeforeResolve = options.onBeforeResolve;
+    }
+    registerProvider(provider) {
+        const existing = this.providers.get(provider.metadata.id);
+        if (existing && existing !== provider) {
+            throw new Error(`Language service provider ${provider.metadata.id} is already registered`);
+        }
+        this.providers.set(provider.metadata.id, provider);
+        return () => {
+            if (this.providers.get(provider.metadata.id) === provider) {
+                this.providers.delete(provider.metadata.id);
+                this.clearProviderFailure(provider.metadata.id);
+                this.clearPublishedDiagnostics();
+                void provider.dispose?.();
+            }
+        };
+    }
+    bindDiagnostics(binding) {
+        this.diagnosticsBinding = binding;
+        this.publishProviderFailures();
+        return () => {
+            if (this.diagnosticsBinding !== binding)
+                return;
+            this.unbindDiagnostics();
+        };
+    }
+    reportProviderFailure(id, error) {
+        this.providerFailures.set(id, {
+            message: providerFailureMessage(id, error),
+            severity: "error",
+            source: "Language service",
+            code: id,
+        });
+        this.publishProviderFailures();
+    }
+    clearProviderFailure(id) {
+        if (!this.providerFailures.delete(id))
+            return;
+        this.publishProviderFailures();
+    }
+    unbindDiagnostics() {
+        this.clearPublishedDiagnostics();
+        this.diagnosticsBinding = null;
+    }
+    retainDocument(uri) {
+        this.openDocuments.set(uri, (this.openDocuments.get(uri) ?? 0) + 1);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const next = (this.openDocuments.get(uri) ?? 1) - 1;
+            if (next > 0) {
+                this.openDocuments.set(uri, next);
+                return;
+            }
+            this.openDocuments.delete(uri);
+            this.documents.delete(uri);
+            this.deleteCachedCodeActions(uri);
+            const collection = this.diagnosticsBinding?.collection;
+            if (collection && !collection.disposed) {
+                collection.delete(resourceForUri(uri));
+            }
+        };
+    }
+    buildDiagnosticItemMenu(menu, entry) {
+        const uri = entry.resource?.uri;
+        if (!uri || !this.diagnosticsBinding)
+            return;
+        const actions = this.cachedCodeActionsFor(uri, entry.diagnostic);
+        if (!actions.length)
+            return;
+        const document = this.documents.get(uri);
+        if (!document)
+            return;
+        for (const action of actions) {
+            menu.addItem((item) => item
+                .setTitle(action.title)
+                .setIcon("lightbulb")
+                .setSection("fix")
+                .onClick(() => this.diagnosticsBinding?.applyCodeAction(document, action)));
+        }
+    }
+    registerGlobalDeclaration(declaration) {
+        this.globals.set(declaration.uri, declaration);
+        return () => {
+            const current = this.globals.get(declaration.uri);
+            if (current === declaration) {
+                this.globals.delete(declaration.uri);
+            }
+        };
+    }
+    updateDocument(document) {
+        this.documents.set(document.uri, document);
+        for (const provider of this.providers.values()) {
+            if (!provider.metadata.languages.includes(document.languageId)) {
+                continue;
+            }
+            void Promise.resolve(provider.updateDocument?.({ document })).catch((error) => {
+                if (this.providers.get(provider.metadata.id) !== provider)
+                    return;
+                console.warn("Language document update failed", {
+                    provider: provider.metadata.id,
+                    error,
+                });
+            });
+        }
+    }
+    getDocument(uri) {
+        return this.documents.get(uri) ?? null;
+    }
+    getGlobalDeclarations() {
+        return [...this.globals.values()].sort((left, right) => left.uri.localeCompare(right.uri));
+    }
+    async diagnostics(document) {
+        this.updateDocument(document);
+        await this.onBeforeResolve?.(document.languageId);
+        const sorted = this.matchingProviders(document.languageId, "diagnostics");
+        if (!sorted.length) {
+            this.publishDiagnostics(document, []);
+            return [];
+        }
+        const skipProviderIds = new Set();
+        const results = await Promise.all(sorted.map(async (provider) => {
+            const result = await this.settleProviderCapability(provider, "diagnostics", provider.provideDiagnostics?.(this.context(document)), []);
+            if (result.timedOut || this.providerFailures.has(provider.metadata.id)) {
+                skipProviderIds.add(provider.metadata.id);
+            }
+            return result.value;
+        }));
+        const diagnostics = results.flatMap((diagnostics) => diagnostics ?? []);
+        await this.cacheCodeActions(document, diagnostics, skipProviderIds);
+        this.publishDiagnostics(document, diagnostics);
+        return diagnostics;
+    }
+    async completions(document, position) {
+        this.updateDocument(document);
+        await this.onBeforeResolve?.(document.languageId);
+        for (const provider of this.providersFor(document.languageId, "completion")) {
+            const completions = await provider
+                .provideCompletions?.(this.context(document), position)
+                .catch((error) => {
+                console.warn("Language completion provider failed", {
+                    provider: provider.metadata.id,
+                    error,
+                });
+                return null;
+            });
+            if (completions?.items.length) {
+                return completions;
+            }
+        }
+        return null;
+    }
+    async hover(document, position) {
+        this.updateDocument(document);
+        await this.onBeforeResolve?.(document.languageId);
+        for (const provider of this.providersFor(document.languageId, "hover")) {
+            const hover = await provider
+                .provideHover?.(this.context(document), position)
+                .catch((error) => {
+                console.warn("Language hover provider failed", {
+                    provider: provider.metadata.id,
+                    error,
+                });
+                return null;
+            });
+            if (hover) {
+                return hover;
+            }
+        }
+        return null;
+    }
+    async definition(document, position) {
+        this.updateDocument(document);
+        await this.onBeforeResolve?.(document.languageId);
+        for (const provider of this.providersFor(document.languageId, "definition")) {
+            const locations = await provider
+                .provideDefinition?.(this.context(document), position)
+                .catch((error) => {
+                console.warn("Language definition provider failed", {
+                    provider: provider.metadata.id,
+                    error,
+                });
+                return [];
+            });
+            if (locations?.length) {
+                return locations;
+            }
+        }
+        return [];
+    }
+    async applyCommand(document, command) {
+        this.updateDocument(document);
+        const context = this.context(document);
+        for (const provider of this.providers.values()) {
+            if (!provider.applyCommand)
+                continue;
+            await Promise.resolve(provider.applyCommand(context, command)).catch((error) => {
+                console.warn("Language command provider failed", {
+                    provider: provider.metadata.id,
+                    command: command.id,
+                    error,
+                });
+            });
+        }
+    }
+    async codeActions(document, range, skipProviderIds) {
+        this.updateDocument(document);
+        await this.onBeforeResolve?.(document.languageId);
+        const sorted = this.matchingProviders(document.languageId, "codeActions");
+        if (!sorted.length) {
+            return [];
+        }
+        const results = await Promise.all(sorted.map((provider) => {
+            if (skipProviderIds?.has(provider.metadata.id)) {
+                return Promise.resolve([]);
+            }
+            return this.settleProviderCapability(provider, "codeActions", provider.provideCodeActions?.(this.context(document), range), []).then((result) => result.value);
+        }));
+        return results.flatMap((actions) => actions ?? []);
+    }
+    cachedCodeActionsFor(uri, diagnostic) {
+        return (this.cachedCodeActions.get(diagnosticCacheKey(uri, diagnostic)) ?? []);
+    }
+    context(document) {
+        return {
+            document,
+            globals: this.getGlobalDeclarations(),
+        };
+    }
+    matchingProviders(languageId, capability) {
+        return [...this.providers.values()]
+            .filter((provider) => provider.metadata.languages.includes(languageId) &&
+            provider.metadata.capabilities[capability])
+            .sort((left, right) => (right.metadata.priority ?? 0) - (left.metadata.priority ?? 0));
+    }
+    providersFor(languageId, capability) {
+        return this.matchingProviders(languageId, capability);
+    }
+    publishDiagnostics(document, diagnostics) {
+        if (!this.diagnosticsBinding ||
+            this.diagnosticsBinding.collection.disposed ||
+            !this.openDocuments.has(document.uri)) {
+            return;
+        }
+        this.diagnosticsBinding.collection.set(resourceForUri(document.uri), diagnostics.map(toWorkspaceDiagnostic));
+    }
+    async cacheCodeActions(document, diagnostics, skipProviderIds) {
+        this.deleteCachedCodeActions(document.uri);
+        await Promise.all(diagnostics.map(async (diagnostic) => {
+            const actions = await this.codeActions(document, diagnostic.range, skipProviderIds);
+            if (!this.openDocuments.has(document.uri))
+                return;
+            this.cachedCodeActions.set(diagnosticCacheKey(document.uri, diagnostic), uniqueActionsForDiagnostic(actions, diagnostic));
+        }));
+    }
+    deleteCachedCodeActions(uri) {
+        const prefix = `${uri}\u0000`;
+        for (const key of this.cachedCodeActions.keys()) {
+            if (key.startsWith(prefix))
+                this.cachedCodeActions.delete(key);
+        }
+    }
+    async settleProviderCapability(provider, capability, request, fallback) {
+        try {
+            const settled = await settleProviderRequest(request, fallback);
+            if (this.providers.get(provider.metadata.id) !== provider) {
+                return { value: fallback, timedOut: false };
+            }
+            if (settled.status === "timeout") {
+                this.reportProviderFailure(provider.metadata.id, new Error(PROVIDER_TIMEOUT_MESSAGE));
+                return { value: fallback, timedOut: true };
+            }
+            this.clearProviderFailure(provider.metadata.id);
+            return { value: settled.value, timedOut: false };
+        }
+        catch (error) {
+            if (this.providers.get(provider.metadata.id) !== provider) {
+                return { value: fallback, timedOut: false };
+            }
+            console.warn(capability === "diagnostics"
+                ? "Language diagnostics provider failed"
+                : "Language code action provider failed", {
+                provider: provider.metadata.id,
+                error,
+            });
+            this.reportProviderFailure(provider.metadata.id, error);
+            return { value: fallback, timedOut: false };
+        }
+    }
+    publishProviderFailures() {
+        const collection = this.diagnosticsBinding?.collection;
+        if (!collection || collection.disposed)
+            return;
+        collection.set(null, [...this.providerFailures.values()]);
+    }
+    clearPublishedDiagnostics() {
+        this.cachedCodeActions.clear();
+        this.providerFailures.clear();
+        const collection = this.diagnosticsBinding?.collection;
+        if (collection && !collection.disposed)
+            collection.clear();
+    }
+}
+function resourceForUri(uri) {
+    const rawPath = uri.startsWith("vault:///")
+        ? uri.slice("vault:///".length)
+        : uri;
+    let detail = rawPath;
+    try {
+        detail = decodeURI(rawPath);
+    }
+    catch {
+        // Preserve an opaque URI when it is not URI encoded.
+    }
+    return {
+        uri,
+        label: detail.split("/").at(-1) || detail,
+        detail,
+        icon: "file-text",
+    };
+}
+function toWorkspaceDiagnostic(diagnostic) {
+    return {
+        message: diagnostic.message,
+        severity: diagnostic.severity,
+        range: diagnostic.range,
+        source: diagnostic.source,
+        code: toWorkspaceDiagnosticCode(diagnostic),
+    };
+}
+function toWorkspaceDiagnosticCode(diagnostic) {
+    const code = diagnostic.code;
+    if (diagnostic.source === "markdownlint" &&
+        typeof code === "string" &&
+        /^MD\d+$/i.test(code)) {
+        return { value: code, target: markdownlintRuleUrl(code) };
+    }
+    return code;
+}
+function diagnosticCacheKey(uri, diagnostic) {
+    return `${uri}\u0000${diagnostic.message}\u0000${String(typeof diagnostic.code === "object"
+        ? diagnostic.code.value
+        : (diagnostic.code ?? ""))}\u0000${JSON.stringify(diagnostic.range ?? null)}`;
+}
+function uniqueActionsForDiagnostic(actions, diagnostic) {
+    const matching = actions.filter((action) => !action.diagnostics?.length ||
+        action.diagnostics.some((entry) => diagnosticsMatch(entry, diagnostic)));
+    const seenTitles = new Set();
+    return matching.filter((action) => {
+        if (seenTitles.has(action.title)) {
+            return false;
+        }
+        seenTitles.add(action.title);
+        return true;
+    });
+}
+function diagnosticsMatch(left, right) {
+    return (left.message === right.message &&
+        String(left.code ?? "") === String(right.code ?? "") &&
+        JSON.stringify(left.range ?? null) === JSON.stringify(right.range ?? null));
+}

package/dist/language-service/types.d.ts

@@ -0,0 +1,92 @@
+export type LanguageServiceRuntime = "worker" | "native" | "lsp" | "in-process";
+export interface LanguageServicePosition {
+    line: number;
+    character: number;
+}
+export interface LanguageServiceRange {
+    start: LanguageServicePosition;
+    end: LanguageServicePosition;
+}
+export interface VirtualDocument {
+    uri: string;
+    languageId: string;
+    version: number;
+    text: string;
+}
+export interface VirtualDocumentUpdate {
+    document: VirtualDocument;
+}
+export type LanguageServiceDiagnosticSeverity = "error" | "warning" | "information" | "hint";
+export interface LanguageServiceDiagnostic {
+    range: LanguageServiceRange;
+    message: string;
+    severity: LanguageServiceDiagnosticSeverity;
+    source?: string;
+    code?: string | number;
+}
+export type LanguageServiceCompletionKind = "text" | "method" | "function" | "constructor" | "field" | "variable" | "class" | "interface" | "module" | "property" | "unit" | "value" | "enum" | "keyword" | "snippet" | "file" | "reference";
+export interface LanguageServiceCompletionItem {
+    label: string;
+    detail?: string;
+    documentation?: string;
+    kind?: LanguageServiceCompletionKind;
+    apply?: string;
+}
+export interface LanguageServiceCompletionList {
+    from?: LanguageServicePosition;
+    to?: LanguageServicePosition;
+    items: LanguageServiceCompletionItem[];
+}
+export interface LanguageServiceHover {
+    range?: LanguageServiceRange;
+    contents: string;
+}
+export interface LanguageServiceLocation {
+    uri: string;
+    range: LanguageServiceRange;
+}
+export interface LanguageServiceCodeActionCommand {
+    id: string;
+    arguments?: unknown[];
+}
+export interface LanguageServiceCodeAction {
+    title: string;
+    kind?: string;
+    diagnostics?: LanguageServiceDiagnostic[];
+    edit?: unknown;
+    command?: LanguageServiceCodeActionCommand;
+}
+export interface LanguageServiceProviderCapabilities {
+    diagnostics?: boolean;
+    completion?: boolean;
+    hover?: boolean;
+    definition?: boolean;
+    codeActions?: boolean;
+}
+export interface LanguageServiceProviderMetadata {
+    id: string;
+    languages: string[];
+    runtime: LanguageServiceRuntime;
+    priority?: number;
+    capabilities: LanguageServiceProviderCapabilities;
+}
+export interface LanguageServiceGlobalDeclaration {
+    uri: string;
+    text: string;
+    version?: number;
+}
+export interface LanguageServiceRequestContext {
+    document: VirtualDocument;
+    globals: LanguageServiceGlobalDeclaration[];
+}
+export interface LanguageServiceProvider {
+    metadata: LanguageServiceProviderMetadata;
+    updateDocument?(update: VirtualDocumentUpdate): Promise<void> | void;
+    provideDiagnostics?(context: LanguageServiceRequestContext): Promise<LanguageServiceDiagnostic[]>;
+    provideCompletions?(context: LanguageServiceRequestContext, position: LanguageServicePosition): Promise<LanguageServiceCompletionList | null>;
+    provideHover?(context: LanguageServiceRequestContext, position: LanguageServicePosition): Promise<LanguageServiceHover | null>;
+    provideDefinition?(context: LanguageServiceRequestContext, position: LanguageServicePosition): Promise<LanguageServiceLocation[]>;
+    provideCodeActions?(context: LanguageServiceRequestContext, range: LanguageServiceRange): Promise<LanguageServiceCodeAction[]>;
+    applyCommand?(context: LanguageServiceRequestContext, command: LanguageServiceCodeActionCommand): Promise<void> | void;
+    dispose?(): Promise<void> | void;
+}

package/dist/language-service/types.js

@@ -0,0 +1 @@
+export {};

package/dist/language-service/virtual-document.d.ts

@@ -0,0 +1,11 @@
+import type { LanguageServicePosition, LanguageServiceRange, VirtualDocument } from "./types";
+export declare function createVirtualDocument(document: Omit<VirtualDocument, "version"> & {
+    version?: number;
+}): VirtualDocument;
+export declare function offsetToLanguageServicePosition(text: string, offset: number): LanguageServicePosition;
+export declare function languageServicePositionToOffset(text: string, position: LanguageServicePosition): number;
+export declare function languageServiceRangeToOffsets(text: string, range: LanguageServiceRange): {
+    from: number;
+    to: number;
+};
+export declare function offsetsToLanguageServiceRange(text: string, from: number, to: number): LanguageServiceRange;