css-variable-lsp 1.0.0 → 1.0.2

package/client/node_modules/vscode-languageclient/lib/common/fileOperations.js

@@ -1,333 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WillDeleteFilesFeature = exports.WillRenameFilesFeature = exports.WillCreateFilesFeature = exports.DidDeleteFilesFeature = exports.DidRenameFilesFeature = exports.DidCreateFilesFeature = void 0;
-const code = require("vscode");
-const minimatch = require("minimatch");
-const proto = require("vscode-languageserver-protocol");
-const UUID = require("./utils/uuid");
-function ensure(target, key) {
-    if (target[key] === void 0) {
-        target[key] = {};
-    }
-    return target[key];
-}
-function access(target, key) {
-    return target[key];
-}
-function assign(target, key, value) {
-    target[key] = value;
-}
-class FileOperationFeature {
-    constructor(client, event, registrationType, clientCapability, serverCapability) {
-        this._client = client;
-        this._event = event;
-        this._registrationType = registrationType;
-        this._clientCapability = clientCapability;
-        this._serverCapability = serverCapability;
-        this._filters = new Map();
-    }
-    getState() {
-        return { kind: 'workspace', id: this._registrationType.method, registrations: this._filters.size > 0 };
-    }
-    filterSize() {
-        return this._filters.size;
-    }
-    get registrationType() {
-        return this._registrationType;
-    }
-    fillClientCapabilities(capabilities) {
-        const value = ensure(ensure(capabilities, 'workspace'), 'fileOperations');
-        // this happens n times but it is the same value so we tolerate this.
-        assign(value, 'dynamicRegistration', true);
-        assign(value, this._clientCapability, true);
-    }
-    initialize(capabilities) {
-        const options = capabilities.workspace?.fileOperations;
-        const capability = options !== undefined ? access(options, this._serverCapability) : undefined;
-        if (capability?.filters !== undefined) {
-            try {
-                this.register({
-                    id: UUID.generateUuid(),
-                    registerOptions: { filters: capability.filters }
-                });
-            }
-            catch (e) {
-                this._client.warn(`Ignoring invalid glob pattern for ${this._serverCapability} registration: ${e}`);
-            }
-        }
-    }
-    register(data) {
-        if (!this._listener) {
-            this._listener = this._event(this.send, this);
-        }
-        const minimatchFilter = data.registerOptions.filters.map((filter) => {
-            const matcher = new minimatch.Minimatch(filter.pattern.glob, FileOperationFeature.asMinimatchOptions(filter.pattern.options));
-            if (!matcher.makeRe()) {
-                throw new Error(`Invalid pattern ${filter.pattern.glob}!`);
-            }
-            return { scheme: filter.scheme, matcher, kind: filter.pattern.matches };
-        });
-        this._filters.set(data.id, minimatchFilter);
-    }
-    unregister(id) {
-        this._filters.delete(id);
-        if (this._filters.size === 0 && this._listener) {
-            this._listener.dispose();
-            this._listener = undefined;
-        }
-    }
-    clear() {
-        this._filters.clear();
-        if (this._listener) {
-            this._listener.dispose();
-            this._listener = undefined;
-        }
-    }
-    getFileType(uri) {
-        return FileOperationFeature.getFileType(uri);
-    }
-    async filter(event, prop) {
-        // (Asynchronously) map each file onto a boolean of whether it matches
-        // any of the globs.
-        const fileMatches = await Promise.all(event.files.map(async (item) => {
-            const uri = prop(item);
-            // Use fsPath to make this consistent with file system watchers but help
-            // minimatch to use '/' instead of `\\` if present.
-            const path = uri.fsPath.replace(/\\/g, '/');
-            for (const filters of this._filters.values()) {
-                for (const filter of filters) {
-                    if (filter.scheme !== undefined && filter.scheme !== uri.scheme) {
-                        continue;
-                    }
-                    if (filter.matcher.match(path)) {
-                        // The pattern matches. If kind is undefined then everything is ok
-                        if (filter.kind === undefined) {
-                            return true;
-                        }
-                        const fileType = await this.getFileType(uri);
-                        // If we can't determine the file type than we treat it as a match.
-                        // Dropping it would be another alternative.
-                        if (fileType === undefined) {
-                            this._client.error(`Failed to determine file type for ${uri.toString()}.`);
-                            return true;
-                        }
-                        if ((fileType === code.FileType.File && filter.kind === proto.FileOperationPatternKind.file) || (fileType === code.FileType.Directory && filter.kind === proto.FileOperationPatternKind.folder)) {
-                            return true;
-                        }
-                    }
-                    else if (filter.kind === proto.FileOperationPatternKind.folder) {
-                        const fileType = await FileOperationFeature.getFileType(uri);
-                        if (fileType === code.FileType.Directory && filter.matcher.match(`${path}/`)) {
-                            return true;
-                        }
-                    }
-                }
-            }
-            return false;
-        }));
-        // Filter the files to those that matched.
-        const files = event.files.filter((_, index) => fileMatches[index]);
-        return { ...event, files };
-    }
-    static async getFileType(uri) {
-        try {
-            return (await code.workspace.fs.stat(uri)).type;
-        }
-        catch (e) {
-            return undefined;
-        }
-    }
-    static asMinimatchOptions(options) {
-        // The spec doesn't state that dot files don't match. So we make
-        // matching those the default.
-        const result = { dot: true };
-        if (options?.ignoreCase === true) {
-            result.nocase = true;
-        }
-        return result;
-    }
-}
-class NotificationFileOperationFeature extends FileOperationFeature {
-    constructor(client, event, notificationType, clientCapability, serverCapability, accessUri, createParams) {
-        super(client, event, notificationType, clientCapability, serverCapability);
-        this._notificationType = notificationType;
-        this._accessUri = accessUri;
-        this._createParams = createParams;
-    }
-    async send(originalEvent) {
-        // Create a copy of the event that has the files filtered to match what the
-        // server wants.
-        const filteredEvent = await this.filter(originalEvent, this._accessUri);
-        if (filteredEvent.files.length) {
-            const next = async (event) => {
-                return this._client.sendNotification(this._notificationType, this._createParams(event));
-            };
-            return this.doSend(filteredEvent, next);
-        }
-    }
-}
-class CachingNotificationFileOperationFeature extends NotificationFileOperationFeature {
-    constructor() {
-        super(...arguments);
-        this._fsPathFileTypes = new Map();
-    }
-    async getFileType(uri) {
-        const fsPath = uri.fsPath;
-        if (this._fsPathFileTypes.has(fsPath)) {
-            return this._fsPathFileTypes.get(fsPath);
-        }
-        const type = await FileOperationFeature.getFileType(uri);
-        if (type) {
-            this._fsPathFileTypes.set(fsPath, type);
-        }
-        return type;
-    }
-    async cacheFileTypes(event, prop) {
-        // Calling filter will force the matching logic to run. For any item
-        // that requires a getFileType lookup, the overriden getFileType will
-        // be called that will cache the result so that when onDidRename fires,
-        // it can still be checked even though the item no longer exists on disk
-        // in its original location.
-        await this.filter(event, prop);
-    }
-    clearFileTypeCache() {
-        this._fsPathFileTypes.clear();
-    }
-    unregister(id) {
-        super.unregister(id);
-        if (this.filterSize() === 0 && this._willListener) {
-            this._willListener.dispose();
-            this._willListener = undefined;
-        }
-    }
-    clear() {
-        super.clear();
-        if (this._willListener) {
-            this._willListener.dispose();
-            this._willListener = undefined;
-        }
-    }
-}
-class DidCreateFilesFeature extends NotificationFileOperationFeature {
-    constructor(client) {
-        super(client, code.workspace.onDidCreateFiles, proto.DidCreateFilesNotification.type, 'didCreate', 'didCreate', (i) => i, client.code2ProtocolConverter.asDidCreateFilesParams);
-    }
-    doSend(event, next) {
-        const middleware = this._client.middleware.workspace;
-        return middleware?.didCreateFiles
-            ? middleware.didCreateFiles(event, next)
-            : next(event);
-    }
-}
-exports.DidCreateFilesFeature = DidCreateFilesFeature;
-class DidRenameFilesFeature extends CachingNotificationFileOperationFeature {
-    constructor(client) {
-        super(client, code.workspace.onDidRenameFiles, proto.DidRenameFilesNotification.type, 'didRename', 'didRename', (i) => i.oldUri, client.code2ProtocolConverter.asDidRenameFilesParams);
-    }
-    register(data) {
-        if (!this._willListener) {
-            this._willListener = code.workspace.onWillRenameFiles(this.willRename, this);
-        }
-        super.register(data);
-    }
-    willRename(e) {
-        e.waitUntil(this.cacheFileTypes(e, (i) => i.oldUri));
-    }
-    doSend(event, next) {
-        this.clearFileTypeCache();
-        const middleware = this._client.middleware.workspace;
-        return middleware?.didRenameFiles
-            ? middleware.didRenameFiles(event, next)
-            : next(event);
-    }
-}
-exports.DidRenameFilesFeature = DidRenameFilesFeature;
-class DidDeleteFilesFeature extends CachingNotificationFileOperationFeature {
-    constructor(client) {
-        super(client, code.workspace.onDidDeleteFiles, proto.DidDeleteFilesNotification.type, 'didDelete', 'didDelete', (i) => i, client.code2ProtocolConverter.asDidDeleteFilesParams);
-    }
-    register(data) {
-        if (!this._willListener) {
-            this._willListener = code.workspace.onWillDeleteFiles(this.willDelete, this);
-        }
-        super.register(data);
-    }
-    willDelete(e) {
-        e.waitUntil(this.cacheFileTypes(e, (i) => i));
-    }
-    doSend(event, next) {
-        this.clearFileTypeCache();
-        const middleware = this._client.middleware.workspace;
-        return middleware?.didDeleteFiles
-            ? middleware.didDeleteFiles(event, next)
-            : next(event);
-    }
-}
-exports.DidDeleteFilesFeature = DidDeleteFilesFeature;
-class RequestFileOperationFeature extends FileOperationFeature {
-    constructor(client, event, requestType, clientCapability, serverCapability, accessUri, createParams) {
-        super(client, event, requestType, clientCapability, serverCapability);
-        this._requestType = requestType;
-        this._accessUri = accessUri;
-        this._createParams = createParams;
-    }
-    async send(originalEvent) {
-        const waitUntil = this.waitUntil(originalEvent);
-        originalEvent.waitUntil(waitUntil);
-    }
-    async waitUntil(originalEvent) {
-        // Create a copy of the event that has the files filtered to match what the
-        // server wants.
-        const filteredEvent = await this.filter(originalEvent, this._accessUri);
-        if (filteredEvent.files.length) {
-            const next = (event) => {
-                return this._client.sendRequest(this._requestType, this._createParams(event), event.token)
-                    .then(this._client.protocol2CodeConverter.asWorkspaceEdit);
-            };
-            return this.doSend(filteredEvent, next);
-        }
-        else {
-            return undefined;
-        }
-    }
-}
-class WillCreateFilesFeature extends RequestFileOperationFeature {
-    constructor(client) {
-        super(client, code.workspace.onWillCreateFiles, proto.WillCreateFilesRequest.type, 'willCreate', 'willCreate', (i) => i, client.code2ProtocolConverter.asWillCreateFilesParams);
-    }
-    doSend(event, next) {
-        const middleware = this._client.middleware.workspace;
-        return middleware?.willCreateFiles
-            ? middleware.willCreateFiles(event, next)
-            : next(event);
-    }
-}
-exports.WillCreateFilesFeature = WillCreateFilesFeature;
-class WillRenameFilesFeature extends RequestFileOperationFeature {
-    constructor(client) {
-        super(client, code.workspace.onWillRenameFiles, proto.WillRenameFilesRequest.type, 'willRename', 'willRename', (i) => i.oldUri, client.code2ProtocolConverter.asWillRenameFilesParams);
-    }
-    doSend(event, next) {
-        const middleware = this._client.middleware.workspace;
-        return middleware?.willRenameFiles
-            ? middleware.willRenameFiles(event, next)
-            : next(event);
-    }
-}
-exports.WillRenameFilesFeature = WillRenameFilesFeature;
-class WillDeleteFilesFeature extends RequestFileOperationFeature {
-    constructor(client) {
-        super(client, code.workspace.onWillDeleteFiles, proto.WillDeleteFilesRequest.type, 'willDelete', 'willDelete', (i) => i, client.code2ProtocolConverter.asWillDeleteFilesParams);
-    }
-    doSend(event, next) {
-        const middleware = this._client.middleware.workspace;
-        return middleware?.willDeleteFiles
-            ? middleware.willDeleteFiles(event, next)
-            : next(event);
-    }
-}
-exports.WillDeleteFilesFeature = WillDeleteFilesFeature;

package/client/node_modules/vscode-languageclient/lib/common/fileSystemWatcher.d.ts

@@ -1,18 +0,0 @@
-import { FileSystemWatcher as VFileSystemWatcher } from 'vscode';
-import { ClientCapabilities, DidChangeWatchedFilesRegistrationOptions, DocumentSelector, FileEvent, RegistrationType, ServerCapabilities } from 'vscode-languageserver-protocol';
-import { FeatureClient, DynamicFeature, RegistrationData, FeatureState } from './features';
-export declare class FileSystemWatcherFeature implements DynamicFeature<DidChangeWatchedFilesRegistrationOptions> {
-    private readonly _client;
-    private readonly _notifyFileEvent;
-    private readonly _watchers;
-    constructor(client: FeatureClient<object>, notifyFileEvent: (event: FileEvent) => void);
-    getState(): FeatureState;
-    get registrationType(): RegistrationType<DidChangeWatchedFilesRegistrationOptions>;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(_capabilities: ServerCapabilities, _documentSelector: DocumentSelector): void;
-    register(data: RegistrationData<DidChangeWatchedFilesRegistrationOptions>): void;
-    registerRaw(id: string, fileSystemWatchers: VFileSystemWatcher[]): void;
-    private hookListeners;
-    unregister(id: string): void;
-    clear(): void;
-}

package/client/node_modules/vscode-languageclient/lib/common/fileSystemWatcher.js

@@ -1,95 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemWatcherFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-class FileSystemWatcherFeature {
-    constructor(client, notifyFileEvent) {
-        this._client = client;
-        this._notifyFileEvent = notifyFileEvent;
-        this._watchers = new Map();
-    }
-    getState() {
-        return { kind: 'workspace', id: this.registrationType.method, registrations: this._watchers.size > 0 };
-    }
-    get registrationType() {
-        return vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type;
-    }
-    fillClientCapabilities(capabilities) {
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'didChangeWatchedFiles').dynamicRegistration = true;
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'didChangeWatchedFiles').relativePatternSupport = true;
-    }
-    initialize(_capabilities, _documentSelector) {
-    }
-    register(data) {
-        if (!Array.isArray(data.registerOptions.watchers)) {
-            return;
-        }
-        const disposables = [];
-        for (const watcher of data.registerOptions.watchers) {
-            const globPattern = this._client.protocol2CodeConverter.asGlobPattern(watcher.globPattern);
-            if (globPattern === undefined) {
-                continue;
-            }
-            let watchCreate = true, watchChange = true, watchDelete = true;
-            if (watcher.kind !== undefined && watcher.kind !== null) {
-                watchCreate = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Create) !== 0;
-                watchChange = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Change) !== 0;
-                watchDelete = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Delete) !== 0;
-            }
-            const fileSystemWatcher = vscode_1.workspace.createFileSystemWatcher(globPattern, !watchCreate, !watchChange, !watchDelete);
-            this.hookListeners(fileSystemWatcher, watchCreate, watchChange, watchDelete, disposables);
-            disposables.push(fileSystemWatcher);
-        }
-        this._watchers.set(data.id, disposables);
-    }
-    registerRaw(id, fileSystemWatchers) {
-        let disposables = [];
-        for (let fileSystemWatcher of fileSystemWatchers) {
-            this.hookListeners(fileSystemWatcher, true, true, true, disposables);
-        }
-        this._watchers.set(id, disposables);
-    }
-    hookListeners(fileSystemWatcher, watchCreate, watchChange, watchDelete, listeners) {
-        if (watchCreate) {
-            fileSystemWatcher.onDidCreate((resource) => this._notifyFileEvent({
-                uri: this._client.code2ProtocolConverter.asUri(resource),
-                type: vscode_languageserver_protocol_1.FileChangeType.Created
-            }), null, listeners);
-        }
-        if (watchChange) {
-            fileSystemWatcher.onDidChange((resource) => this._notifyFileEvent({
-                uri: this._client.code2ProtocolConverter.asUri(resource),
-                type: vscode_languageserver_protocol_1.FileChangeType.Changed
-            }), null, listeners);
-        }
-        if (watchDelete) {
-            fileSystemWatcher.onDidDelete((resource) => this._notifyFileEvent({
-                uri: this._client.code2ProtocolConverter.asUri(resource),
-                type: vscode_languageserver_protocol_1.FileChangeType.Deleted
-            }), null, listeners);
-        }
-    }
-    unregister(id) {
-        let disposables = this._watchers.get(id);
-        if (disposables) {
-            for (let disposable of disposables) {
-                disposable.dispose();
-            }
-        }
-    }
-    clear() {
-        this._watchers.forEach((disposables) => {
-            for (let disposable of disposables) {
-                disposable.dispose();
-            }
-        });
-        this._watchers.clear();
-    }
-}
-exports.FileSystemWatcherFeature = FileSystemWatcherFeature;

package/client/node_modules/vscode-languageclient/lib/common/foldingRange.d.ts

@@ -1,19 +0,0 @@
-import { Disposable, TextDocument, ProviderResult, FoldingRange as VFoldingRange, FoldingContext, FoldingRangeProvider, EventEmitter } from 'vscode';
-import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, FoldingRangeRegistrationOptions, FoldingRangeOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient } from './features';
-export interface ProvideFoldingRangeSignature {
-    (this: void, document: TextDocument, context: FoldingContext, token: CancellationToken): ProviderResult<VFoldingRange[]>;
-}
-export interface FoldingRangeProviderMiddleware {
-    provideFoldingRanges?: (this: void, document: TextDocument, context: FoldingContext, token: CancellationToken, next: ProvideFoldingRangeSignature) => ProviderResult<VFoldingRange[]>;
-}
-export type FoldingRangeProviderShape = {
-    provider: FoldingRangeProvider;
-    onDidChangeFoldingRange: EventEmitter<void>;
-};
-export declare class FoldingRangeFeature extends TextDocumentLanguageFeature<boolean | FoldingRangeOptions, FoldingRangeRegistrationOptions, FoldingRangeProviderShape, FoldingRangeProviderMiddleware> {
-    constructor(client: FeatureClient<FoldingRangeProviderMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: FoldingRangeRegistrationOptions): [Disposable, FoldingRangeProviderShape];
-}

package/client/node_modules/vscode-languageclient/lib/common/foldingRange.js

@@ -1,65 +0,0 @@
-"use strict";
-/* --------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- * ------------------------------------------------------------------------------------------ */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FoldingRangeFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-class FoldingRangeFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.FoldingRangeRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        let capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'foldingRange');
-        capability.dynamicRegistration = true;
-        capability.rangeLimit = 5000;
-        capability.lineFoldingOnly = true;
-        capability.foldingRangeKind = { valueSet: [vscode_languageserver_protocol_1.FoldingRangeKind.Comment, vscode_languageserver_protocol_1.FoldingRangeKind.Imports, vscode_languageserver_protocol_1.FoldingRangeKind.Region] };
-        capability.foldingRange = { collapsedText: false };
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'foldingRange').refreshSupport = true;
-    }
-    initialize(capabilities, documentSelector) {
-        this._client.onRequest(vscode_languageserver_protocol_1.FoldingRangeRefreshRequest.type, async () => {
-            for (const provider of this.getAllProviders()) {
-                provider.onDidChangeFoldingRange.fire();
-            }
-        });
-        let [id, options] = this.getRegistration(documentSelector, capabilities.foldingRangeProvider);
-        if (!id || !options) {
-            return;
-        }
-        this.register({ id: id, registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const eventEmitter = new vscode_1.EventEmitter();
-        const provider = {
-            onDidChangeFoldingRanges: eventEmitter.event,
-            provideFoldingRanges: (document, context, token) => {
-                const client = this._client;
-                const provideFoldingRanges = (document, _, token) => {
-                    const requestParams = {
-                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document)
-                    };
-                    return client.sendRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, requestParams, token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asFoldingRanges(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideFoldingRanges
-                    ? middleware.provideFoldingRanges(document, context, token, provideFoldingRanges)
-                    : provideFoldingRanges(document, context, token);
-            }
-        };
-        return [vscode_1.languages.registerFoldingRangeProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), { provider: provider, onDidChangeFoldingRange: eventEmitter }];
-    }
-}
-exports.FoldingRangeFeature = FoldingRangeFeature;

package/client/node_modules/vscode-languageclient/lib/common/formatting.d.ts

@@ -1,39 +0,0 @@
-import { Disposable, TextDocument, ProviderResult, Range as VRange, Position as VPosition, TextEdit as VTextEdit, FormattingOptions as VFormattingOptions, DocumentFormattingEditProvider, DocumentRangeFormattingEditProvider, OnTypeFormattingEditProvider } from 'vscode';
-import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, DocumentHighlightRegistrationOptions, DocumentFormattingOptions, TextDocumentRegistrationOptions, DocumentRangeFormattingRegistrationOptions, DocumentRangeFormattingOptions, DocumentOnTypeFormattingOptions, DocumentOnTypeFormattingRegistrationOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient } from './features';
-export interface ProvideDocumentFormattingEditsSignature {
-    (this: void, document: TextDocument, options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
-}
-export interface ProvideDocumentRangeFormattingEditsSignature {
-    (this: void, document: TextDocument, range: VRange, options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
-}
-export interface ProvideDocumentRangesFormattingEditsSignature {
-    (this: void, document: TextDocument, ranges: VRange[], options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
-}
-export interface ProvideOnTypeFormattingEditsSignature {
-    (this: void, document: TextDocument, position: VPosition, ch: string, options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
-}
-export interface FormattingMiddleware {
-    provideDocumentFormattingEdits?: (this: void, document: TextDocument, options: VFormattingOptions, token: CancellationToken, next: ProvideDocumentFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
-    provideDocumentRangeFormattingEdits?: (this: void, document: TextDocument, range: VRange, options: VFormattingOptions, token: CancellationToken, next: ProvideDocumentRangeFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
-    provideDocumentRangesFormattingEdits?: (this: void, document: TextDocument, range: VRange[], options: VFormattingOptions, token: CancellationToken, next: ProvideDocumentRangesFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
-    provideOnTypeFormattingEdits?: (this: void, document: TextDocument, position: VPosition, ch: string, options: VFormattingOptions, token: CancellationToken, next: ProvideOnTypeFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
-}
-export declare class DocumentFormattingFeature extends TextDocumentLanguageFeature<boolean | DocumentFormattingOptions, DocumentHighlightRegistrationOptions, DocumentFormattingEditProvider, FormattingMiddleware> {
-    constructor(client: FeatureClient<FormattingMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: TextDocumentRegistrationOptions): [Disposable, DocumentFormattingEditProvider];
-}
-export declare class DocumentRangeFormattingFeature extends TextDocumentLanguageFeature<boolean | DocumentRangeFormattingOptions, DocumentRangeFormattingRegistrationOptions, DocumentRangeFormattingEditProvider, FormattingMiddleware> {
-    constructor(client: FeatureClient<FormattingMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: DocumentRangeFormattingRegistrationOptions): [Disposable, DocumentRangeFormattingEditProvider];
-}
-export declare class DocumentOnTypeFormattingFeature extends TextDocumentLanguageFeature<DocumentOnTypeFormattingOptions, DocumentOnTypeFormattingRegistrationOptions, OnTypeFormattingEditProvider, FormattingMiddleware> {
-    constructor(client: FeatureClient<FormattingMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: DocumentOnTypeFormattingRegistrationOptions): [Disposable, OnTypeFormattingEditProvider];
-}