css-variable-lsp 1.0.0 → 1.0.1

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

@@ -1,179 +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.SemanticTokensFeature = void 0;
-const vscode = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-const Is = require("./utils/is");
-class SemanticTokensFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.SemanticTokensRegistrationType.type);
-    }
-    fillClientCapabilities(capabilities) {
-        const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'semanticTokens');
-        capability.dynamicRegistration = true;
-        capability.tokenTypes = [
-            vscode_languageserver_protocol_1.SemanticTokenTypes.namespace,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.type,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.class,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.enum,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.interface,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.struct,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.typeParameter,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.parameter,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.variable,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.property,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.enumMember,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.event,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.function,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.method,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.macro,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.keyword,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.modifier,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.comment,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.string,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.number,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.regexp,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.operator,
-            vscode_languageserver_protocol_1.SemanticTokenTypes.decorator
-        ];
-        capability.tokenModifiers = [
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.declaration,
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.definition,
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.readonly,
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.static,
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.deprecated,
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.abstract,
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.async,
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.modification,
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.documentation,
-            vscode_languageserver_protocol_1.SemanticTokenModifiers.defaultLibrary
-        ];
-        capability.formats = [vscode_languageserver_protocol_1.TokenFormat.Relative];
-        capability.requests = {
-            range: true,
-            full: {
-                delta: true
-            }
-        };
-        capability.multilineTokenSupport = false;
-        capability.overlappingTokenSupport = false;
-        capability.serverCancelSupport = true;
-        capability.augmentsSyntaxTokens = true;
-        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'semanticTokens').refreshSupport = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const client = this._client;
-        client.onRequest(vscode_languageserver_protocol_1.SemanticTokensRefreshRequest.type, async () => {
-            for (const provider of this.getAllProviders()) {
-                provider.onDidChangeSemanticTokensEmitter.fire();
-            }
-        });
-        const [id, options] = this.getRegistration(documentSelector, capabilities.semanticTokensProvider);
-        if (!id || !options) {
-            return;
-        }
-        this.register({ id: id, registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const fullProvider = Is.boolean(options.full) ? options.full : options.full !== undefined;
-        const hasEditProvider = options.full !== undefined && typeof options.full !== 'boolean' && options.full.delta === true;
-        const eventEmitter = new vscode.EventEmitter();
-        const documentProvider = fullProvider
-            ? {
-                onDidChangeSemanticTokens: eventEmitter.event,
-                provideDocumentSemanticTokens: (document, token) => {
-                    const client = this._client;
-                    const middleware = client.middleware;
-                    const provideDocumentSemanticTokens = (document, token) => {
-                        const params = {
-                            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document)
-                        };
-                        return client.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRequest.type, params, token).then((result) => {
-                            if (token.isCancellationRequested) {
-                                return null;
-                            }
-                            return client.protocol2CodeConverter.asSemanticTokens(result, token);
-                        }, (error) => {
-                            return client.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensRequest.type, token, error, null);
-                        });
-                    };
-                    return middleware.provideDocumentSemanticTokens
-                        ? middleware.provideDocumentSemanticTokens(document, token, provideDocumentSemanticTokens)
-                        : provideDocumentSemanticTokens(document, token);
-                },
-                provideDocumentSemanticTokensEdits: hasEditProvider
-                    ? (document, previousResultId, token) => {
-                        const client = this._client;
-                        const middleware = client.middleware;
-                        const provideDocumentSemanticTokensEdits = (document, previousResultId, token) => {
-                            const params = {
-                                textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
-                                previousResultId
-                            };
-                            return client.sendRequest(vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type, params, token).then(async (result) => {
-                                if (token.isCancellationRequested) {
-                                    return null;
-                                }
-                                if (vscode_languageserver_protocol_1.SemanticTokens.is(result)) {
-                                    return await client.protocol2CodeConverter.asSemanticTokens(result, token);
-                                }
-                                else {
-                                    return await client.protocol2CodeConverter.asSemanticTokensEdits(result, token);
-                                }
-                            }, (error) => {
-                                return client.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type, token, error, null);
-                            });
-                        };
-                        return middleware.provideDocumentSemanticTokensEdits
-                            ? middleware.provideDocumentSemanticTokensEdits(document, previousResultId, token, provideDocumentSemanticTokensEdits)
-                            : provideDocumentSemanticTokensEdits(document, previousResultId, token);
-                    }
-                    : undefined
-            }
-            : undefined;
-        const hasRangeProvider = options.range === true;
-        const rangeProvider = hasRangeProvider
-            ? {
-                provideDocumentRangeSemanticTokens: (document, range, token) => {
-                    const client = this._client;
-                    const middleware = client.middleware;
-                    const provideDocumentRangeSemanticTokens = (document, range, token) => {
-                        const params = {
-                            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
-                            range: client.code2ProtocolConverter.asRange(range)
-                        };
-                        return client.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type, params, token).then((result) => {
-                            if (token.isCancellationRequested) {
-                                return null;
-                            }
-                            return client.protocol2CodeConverter.asSemanticTokens(result, token);
-                        }, (error) => {
-                            return client.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type, token, error, null);
-                        });
-                    };
-                    return middleware.provideDocumentRangeSemanticTokens
-                        ? middleware.provideDocumentRangeSemanticTokens(document, range, token, provideDocumentRangeSemanticTokens)
-                        : provideDocumentRangeSemanticTokens(document, range, token);
-                }
-            }
-            : undefined;
-        const disposables = [];
-        const client = this._client;
-        const legend = client.protocol2CodeConverter.asSemanticTokensLegend(options.legend);
-        const documentSelector = client.protocol2CodeConverter.asDocumentSelector(selector);
-        if (documentProvider !== undefined) {
-            disposables.push(vscode.languages.registerDocumentSemanticTokensProvider(documentSelector, documentProvider, legend));
-        }
-        if (rangeProvider !== undefined) {
-            disposables.push(vscode.languages.registerDocumentRangeSemanticTokensProvider(documentSelector, rangeProvider, legend));
-        }
-        return [new vscode.Disposable(() => disposables.forEach(item => item.dispose())), { range: rangeProvider, full: documentProvider, onDidChangeSemanticTokensEmitter: eventEmitter }];
-    }
-}
-exports.SemanticTokensFeature = SemanticTokensFeature;

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

@@ -1,16 +0,0 @@
-import { TextDocument, Disposable, Position as VPosition, CancellationToken, ProviderResult, SignatureHelpProvider, SignatureHelpContext as VSignatureHelpContext, SignatureHelp as VSignatureHelp } from 'vscode';
-import { ClientCapabilities, DocumentSelector, ServerCapabilities, SignatureHelpOptions, SignatureHelpRegistrationOptions } from 'vscode-languageserver-protocol';
-import { FeatureClient, TextDocumentLanguageFeature, DocumentSelectorOptions } from './features';
-export interface ProvideSignatureHelpSignature {
-    (this: void, document: TextDocument, position: VPosition, context: VSignatureHelpContext, token: CancellationToken): ProviderResult<VSignatureHelp>;
-}
-export interface SignatureHelpMiddleware {
-    provideSignatureHelp?: (this: void, document: TextDocument, position: VPosition, context: VSignatureHelpContext, token: CancellationToken, next: ProvideSignatureHelpSignature) => ProviderResult<VSignatureHelp>;
-}
-export declare class SignatureHelpFeature extends TextDocumentLanguageFeature<SignatureHelpOptions, SignatureHelpRegistrationOptions, SignatureHelpProvider, SignatureHelpMiddleware> {
-    constructor(client: FeatureClient<SignatureHelpMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: SignatureHelpRegistrationOptions & DocumentSelectorOptions): [Disposable, SignatureHelpProvider];
-    private registerProvider;
-}

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

@@ -1,71 +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.SignatureHelpFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-const UUID = require("./utils/uuid");
-class SignatureHelpFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.SignatureHelpRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        let config = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'signatureHelp');
-        config.dynamicRegistration = true;
-        config.signatureInformation = { documentationFormat: [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText] };
-        config.signatureInformation.parameterInformation = { labelOffsetSupport: true };
-        config.signatureInformation.activeParameterSupport = true;
-        config.contextSupport = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const options = this.getRegistrationOptions(documentSelector, capabilities.signatureHelpProvider);
-        if (!options) {
-            return;
-        }
-        this.register({
-            id: UUID.generateUuid(),
-            registerOptions: options
-        });
-    }
-    registerLanguageProvider(options) {
-        const provider = {
-            provideSignatureHelp: (document, position, token, context) => {
-                const client = this._client;
-                const providerSignatureHelp = (document, position, context, token) => {
-                    return client.sendRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, client.code2ProtocolConverter.asSignatureHelpParams(document, position, context), token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asSignatureHelp(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideSignatureHelp
-                    ? middleware.provideSignatureHelp(document, position, context, token, providerSignatureHelp)
-                    : providerSignatureHelp(document, position, context, token);
-            }
-        };
-        return [this.registerProvider(options, provider), provider];
-    }
-    registerProvider(options, provider) {
-        const selector = this._client.protocol2CodeConverter.asDocumentSelector(options.documentSelector);
-        if (options.retriggerCharacters === undefined) {
-            const triggerCharacters = options.triggerCharacters || [];
-            return vscode_1.languages.registerSignatureHelpProvider(selector, provider, ...triggerCharacters);
-        }
-        else {
-            const metaData = {
-                triggerCharacters: options.triggerCharacters || [],
-                retriggerCharacters: options.retriggerCharacters || []
-            };
-            return vscode_1.languages.registerSignatureHelpProvider(selector, provider, metaData);
-        }
-    }
-}
-exports.SignatureHelpFeature = SignatureHelpFeature;

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

@@ -1,101 +0,0 @@
-import { TextDocument, TextDocumentChangeEvent, TextDocumentWillSaveEvent, TextEdit as VTextEdit, DocumentSelector as VDocumentSelector, Event } from 'vscode';
-import { ClientCapabilities, DidChangeTextDocumentParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams, DocumentSelector, ProtocolNotificationType, RegistrationType, ServerCapabilities, TextDocumentChangeRegistrationOptions, TextDocumentRegistrationOptions, TextDocumentSaveRegistrationOptions, TextDocumentSyncKind, TextDocumentSyncOptions, WillSaveTextDocumentParams } from 'vscode-languageserver-protocol';
-import { FeatureClient, TextDocumentEventFeature, DynamicFeature, NextSignature, TextDocumentSendFeature, NotifyingFeature, RegistrationData, DynamicDocumentFeature, NotificationSendEvent } from './features';
-export interface TextDocumentSynchronizationMiddleware {
-    didOpen?: NextSignature<TextDocument, Promise<void>>;
-    didChange?: NextSignature<TextDocumentChangeEvent, Promise<void>>;
-    willSave?: NextSignature<TextDocumentWillSaveEvent, Promise<void>>;
-    willSaveWaitUntil?: NextSignature<TextDocumentWillSaveEvent, Thenable<VTextEdit[]>>;
-    didSave?: NextSignature<TextDocument, Promise<void>>;
-    didClose?: NextSignature<TextDocument, Promise<void>>;
-}
-export interface DidOpenTextDocumentFeatureShape extends DynamicFeature<TextDocumentRegistrationOptions>, TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>, NotifyingFeature<DidOpenTextDocumentParams> {
-    openDocuments: Iterable<TextDocument>;
-}
-export type ResolvedTextDocumentSyncCapabilities = {
-    resolvedTextDocumentSync?: TextDocumentSyncOptions;
-};
-export declare class DidOpenTextDocumentFeature extends TextDocumentEventFeature<DidOpenTextDocumentParams, TextDocument, TextDocumentSynchronizationMiddleware> implements DidOpenTextDocumentFeatureShape {
-    private readonly _syncedDocuments;
-    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>, syncedDocuments: Map<string, TextDocument>);
-    get openDocuments(): IterableIterator<TextDocument>;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    get registrationType(): RegistrationType<TextDocumentRegistrationOptions>;
-    register(data: RegistrationData<TextDocumentRegistrationOptions>): void;
-    protected getTextDocument(data: TextDocument): TextDocument;
-    protected notificationSent(textDocument: TextDocument, type: ProtocolNotificationType<DidOpenTextDocumentParams, TextDocumentRegistrationOptions>, params: DidOpenTextDocumentParams): void;
-}
-export interface DidCloseTextDocumentFeatureShape extends DynamicFeature<TextDocumentRegistrationOptions>, TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>, NotifyingFeature<DidCloseTextDocumentParams> {
-}
-export declare class DidCloseTextDocumentFeature extends TextDocumentEventFeature<DidCloseTextDocumentParams, TextDocument, TextDocumentSynchronizationMiddleware> implements DidCloseTextDocumentFeatureShape {
-    private readonly _syncedDocuments;
-    private readonly _pendingTextDocumentChanges;
-    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>, syncedDocuments: Map<string, TextDocument>, pendingTextDocumentChanges: Map<string, TextDocument>);
-    get registrationType(): RegistrationType<TextDocumentRegistrationOptions>;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected callback(data: TextDocument): Promise<void>;
-    protected getTextDocument(data: TextDocument): TextDocument;
-    protected notificationSent(textDocument: TextDocument, type: ProtocolNotificationType<DidCloseTextDocumentParams, TextDocumentRegistrationOptions>, params: DidCloseTextDocumentParams): void;
-    unregister(id: string): void;
-}
-export interface DidChangeTextDocumentFeatureShape extends DynamicFeature<TextDocumentChangeRegistrationOptions>, TextDocumentSendFeature<(event: TextDocumentChangeEvent) => Promise<void>>, NotifyingFeature<DidChangeTextDocumentParams> {
-}
-export declare class DidChangeTextDocumentFeature extends DynamicDocumentFeature<TextDocumentChangeRegistrationOptions, TextDocumentSynchronizationMiddleware> implements DidChangeTextDocumentFeatureShape {
-    private _listener;
-    private readonly _changeData;
-    private readonly _onNotificationSent;
-    private readonly _onPendingChangeAdded;
-    private readonly _pendingTextDocumentChanges;
-    private _syncKind;
-    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>, pendingTextDocumentChanges: Map<string, TextDocument>);
-    get onNotificationSent(): Event<NotificationSendEvent<DidChangeTextDocumentParams>>;
-    get onPendingChangeAdded(): Event<void>;
-    get syncKind(): TextDocumentSyncKind;
-    get registrationType(): RegistrationType<TextDocumentChangeRegistrationOptions>;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    register(data: RegistrationData<TextDocumentChangeRegistrationOptions>): void;
-    getDocumentSelectors(): IterableIterator<VDocumentSelector>;
-    private callback;
-    notificationSent(textDocument: TextDocument, type: ProtocolNotificationType<DidChangeTextDocumentParams, TextDocumentRegistrationOptions>, params: DidChangeTextDocumentParams): void;
-    unregister(id: string): void;
-    clear(): void;
-    getPendingDocumentChanges(excludes: Set<string>): TextDocument[];
-    getProvider(document: TextDocument): {
-        send: (event: TextDocumentChangeEvent) => Promise<void>;
-    } | undefined;
-    private updateSyncKind;
-}
-export declare class WillSaveFeature extends TextDocumentEventFeature<WillSaveTextDocumentParams, TextDocumentWillSaveEvent, TextDocumentSynchronizationMiddleware> {
-    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>);
-    get registrationType(): RegistrationType<TextDocumentRegistrationOptions>;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected getTextDocument(data: TextDocumentWillSaveEvent): TextDocument;
-}
-export declare class WillSaveWaitUntilFeature extends DynamicDocumentFeature<TextDocumentRegistrationOptions, TextDocumentSynchronizationMiddleware> {
-    private _listener;
-    private readonly _selectors;
-    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>);
-    protected getDocumentSelectors(): IterableIterator<VDocumentSelector>;
-    get registrationType(): RegistrationType<TextDocumentRegistrationOptions>;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    register(data: RegistrationData<TextDocumentRegistrationOptions>): void;
-    private callback;
-    unregister(id: string): void;
-    clear(): void;
-}
-export interface DidSaveTextDocumentFeatureShape extends DynamicFeature<TextDocumentRegistrationOptions>, TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>, NotifyingFeature<DidSaveTextDocumentParams> {
-}
-export declare class DidSaveTextDocumentFeature extends TextDocumentEventFeature<DidSaveTextDocumentParams, TextDocument, TextDocumentSynchronizationMiddleware> implements DidSaveTextDocumentFeatureShape {
-    private _includeText;
-    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>);
-    get registrationType(): RegistrationType<TextDocumentSaveRegistrationOptions>;
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    register(data: RegistrationData<TextDocumentSaveRegistrationOptions>): void;
-    protected getTextDocument(data: TextDocument): TextDocument;
-}