css-variable-lsp 1.0.0 → 1.0.1

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

@@ -1,54 +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.DeclarationFeature = void 0;
-const vscode_1 = require("vscode");
-const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
-const features_1 = require("./features");
-class DeclarationFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.DeclarationRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        const declarationSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'declaration');
-        declarationSupport.dynamicRegistration = true;
-        declarationSupport.linkSupport = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const [id, options] = this.getRegistration(documentSelector, capabilities.declarationProvider);
-        if (!id || !options) {
-            return;
-        }
-        this.register({ id: id, registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const provider = {
-            provideDeclaration: (document, position, token) => {
-                const client = this._client;
-                const provideDeclaration = (document, position, token) => {
-                    return client.sendRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asDeclarationResult(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideDeclaration
-                    ? middleware.provideDeclaration(document, position, token, provideDeclaration)
-                    : provideDeclaration(document, position, token);
-            }
-        };
-        return [this.registerProvider(selector, provider), provider];
-    }
-    registerProvider(selector, provider) {
-        return vscode_1.languages.registerDeclarationProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
-    }
-}
-exports.DeclarationFeature = DeclarationFeature;

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

@@ -1,16 +0,0 @@
-import { TextDocument, Disposable, Position as VPosition, CancellationToken, ProviderResult, DefinitionProvider, Definition as VDefinition, DefinitionLink as VDefinitionLink } from 'vscode';
-import { ClientCapabilities, DefinitionOptions, DefinitionRegistrationOptions, DocumentSelector, ServerCapabilities } from 'vscode-languageserver-protocol';
-import { FeatureClient, TextDocumentLanguageFeature } from './features';
-export interface ProvideDefinitionSignature {
-    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDefinition | VDefinitionLink[]>;
-}
-export interface DefinitionMiddleware {
-    provideDefinition?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideDefinitionSignature) => ProviderResult<VDefinition | VDefinitionLink[]>;
-}
-export declare class DefinitionFeature extends TextDocumentLanguageFeature<boolean | DefinitionOptions, DefinitionRegistrationOptions, DefinitionProvider, DefinitionMiddleware> {
-    constructor(client: FeatureClient<DefinitionMiddleware>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    protected registerLanguageProvider(options: DefinitionRegistrationOptions): [Disposable, DefinitionProvider];
-    private registerProvider;
-}

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

@@ -1,55 +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.DefinitionFeature = 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 DefinitionFeature extends features_1.TextDocumentLanguageFeature {
-    constructor(client) {
-        super(client, vscode_languageserver_protocol_1.DefinitionRequest.type);
-    }
-    fillClientCapabilities(capabilities) {
-        let definitionSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'definition');
-        definitionSupport.dynamicRegistration = true;
-        definitionSupport.linkSupport = true;
-    }
-    initialize(capabilities, documentSelector) {
-        const options = this.getRegistrationOptions(documentSelector, capabilities.definitionProvider);
-        if (!options) {
-            return;
-        }
-        this.register({ id: UUID.generateUuid(), registerOptions: options });
-    }
-    registerLanguageProvider(options) {
-        const selector = options.documentSelector;
-        const provider = {
-            provideDefinition: (document, position, token) => {
-                const client = this._client;
-                const provideDefinition = (document, position, token) => {
-                    return client.sendRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then((result) => {
-                        if (token.isCancellationRequested) {
-                            return null;
-                        }
-                        return client.protocol2CodeConverter.asDefinitionResult(result, token);
-                    }, (error) => {
-                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, token, error, null);
-                    });
-                };
-                const middleware = client.middleware;
-                return middleware.provideDefinition
-                    ? middleware.provideDefinition(document, position, token, provideDefinition)
-                    : provideDefinition(document, position, token);
-            }
-        };
-        return [this.registerProvider(selector, provider), provider];
-    }
-    registerProvider(selector, provider) {
-        return vscode_1.languages.registerDefinitionProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
-    }
-}
-exports.DefinitionFeature = DefinitionFeature;

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

@@ -1,122 +0,0 @@
-import { Disposable, CancellationToken, ProviderResult, Diagnostic as VDiagnostic, TextDocument, Event as VEvent, EventEmitter, Uri } from 'vscode';
-import { ClientCapabilities, ServerCapabilities, DocumentSelector, DiagnosticRegistrationOptions, DiagnosticOptions } from 'vscode-languageserver-protocol';
-import { TextDocumentLanguageFeature, FeatureClient } from './features';
-export declare namespace vsdiag {
-    enum DocumentDiagnosticReportKind {
-        full = "full",
-        unChanged = "unChanged"
-    }
-    interface FullDocumentDiagnosticReport {
-        kind: DocumentDiagnosticReportKind.full;
-        resultId?: string;
-        items: VDiagnostic[];
-    }
-    interface RelatedFullDocumentDiagnosticReport extends FullDocumentDiagnosticReport {
-        relatedDocuments?: {
-            [uri: string /** DocumentUri */]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport;
-        };
-    }
-    interface UnchangedDocumentDiagnosticReport {
-        kind: DocumentDiagnosticReportKind.unChanged;
-        resultId: string;
-    }
-    interface RelatedUnchangedDocumentDiagnosticReport extends UnchangedDocumentDiagnosticReport {
-        relatedDocuments?: {
-            [uri: string /** DocumentUri */]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport;
-        };
-    }
-    type DocumentDiagnosticReport = RelatedFullDocumentDiagnosticReport | RelatedUnchangedDocumentDiagnosticReport;
-    type PreviousResultId = {
-        uri: Uri;
-        value: string;
-    };
-    interface WorkspaceFullDocumentDiagnosticReport extends FullDocumentDiagnosticReport {
-        uri: Uri;
-        version: number | null;
-    }
-    interface WorkspaceUnchangedDocumentDiagnosticReport extends UnchangedDocumentDiagnosticReport {
-        uri: Uri;
-        version: number | null;
-    }
-    type WorkspaceDocumentDiagnosticReport = WorkspaceFullDocumentDiagnosticReport | WorkspaceUnchangedDocumentDiagnosticReport;
-    interface WorkspaceDiagnosticReport {
-        items: WorkspaceDocumentDiagnosticReport[];
-    }
-    interface WorkspaceDiagnosticReportPartialResult {
-        items: WorkspaceDocumentDiagnosticReport[];
-    }
-    interface ResultReporter {
-        (chunk: WorkspaceDiagnosticReportPartialResult | null): void;
-    }
-    interface DiagnosticProvider {
-        onDidChangeDiagnostics: VEvent<void>;
-        provideDiagnostics(document: TextDocument | Uri, previousResultId: string | undefined, token: CancellationToken): ProviderResult<DocumentDiagnosticReport>;
-        provideWorkspaceDiagnostics?(resultIds: PreviousResultId[], token: CancellationToken, resultReporter: ResultReporter): ProviderResult<WorkspaceDiagnosticReport>;
-    }
-}
-export type ProvideDiagnosticSignature = (this: void, document: TextDocument | Uri, previousResultId: string | undefined, token: CancellationToken) => ProviderResult<vsdiag.DocumentDiagnosticReport>;
-export type ProvideWorkspaceDiagnosticSignature = (this: void, resultIds: vsdiag.PreviousResultId[], token: CancellationToken, resultReporter: vsdiag.ResultReporter) => ProviderResult<vsdiag.WorkspaceDiagnosticReport>;
-export type DiagnosticProviderMiddleware = {
-    provideDiagnostics?: (this: void, document: TextDocument | Uri, previousResultId: string | undefined, token: CancellationToken, next: ProvideDiagnosticSignature) => ProviderResult<vsdiag.DocumentDiagnosticReport>;
-    provideWorkspaceDiagnostics?: (this: void, resultIds: vsdiag.PreviousResultId[], token: CancellationToken, resultReporter: vsdiag.ResultReporter, next: ProvideWorkspaceDiagnosticSignature) => ProviderResult<vsdiag.WorkspaceDiagnosticReport>;
-};
-export declare enum DiagnosticPullMode {
-    onType = "onType",
-    onSave = "onSave"
-}
-export type DiagnosticPullOptions = {
-    /**
-     * Whether to pull for diagnostics on document change.
-     */
-    onChange?: boolean;
-    /**
-     * Whether to pull for diagnostics on document save.
-     */
-    onSave?: boolean;
-    /**
-     * An optional filter method that is consulted when triggering a
-     * diagnostic pull during document change or document save.
-     *
-     * The document gets filtered if the method returns `true`.
-     *
-     * @param document The document that changed or got saved.
-     * @param mode The pull mode.
-     * @returns whether the document should be filtered (`true`) or not.
-     */
-    filter?(document: TextDocument, mode: DiagnosticPullMode): boolean;
-    /**
-     * Whether to pull for diagnostics on resources of non instantiated
-     * tabs. If it is set to true it is highly recommended to provide
-     * a match method as well. Otherwise the client will not pull for
-     * tabs if the used document selector specifies a language property
-     * since the language value is not known for resources.
-     */
-    onTabs?: boolean;
-    /**
-     * An optional match method that is consulted when pulling for diagnostics
-     * when only a URI is known (e.g. for not instantiated tabs)
-     *
-     * The method should return `true` if the document selector matches the
-     * given resource. See also the `vscode.languages.match` function.
-     *
-     * @param documentSelector The document selector.
-     * @param resource The resource.
-     * @returns whether the resource is matched by the given document selector.
-     */
-    match?(documentSelector: DocumentSelector, resource: Uri): boolean;
-};
-export type $DiagnosticPullOptions = {
-    diagnosticPullOptions?: DiagnosticPullOptions;
-};
-export type DiagnosticProviderShape = {
-    onDidChangeDiagnosticsEmitter: EventEmitter<void>;
-    diagnostics: vsdiag.DiagnosticProvider;
-};
-export declare class DiagnosticFeature extends TextDocumentLanguageFeature<DiagnosticOptions, DiagnosticRegistrationOptions, DiagnosticProviderShape, DiagnosticProviderMiddleware, $DiagnosticPullOptions> {
-    private tabs;
-    constructor(client: FeatureClient<DiagnosticProviderMiddleware, $DiagnosticPullOptions>);
-    fillClientCapabilities(capabilities: ClientCapabilities): void;
-    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
-    clear(): void;
-    protected registerLanguageProvider(options: DiagnosticRegistrationOptions): [Disposable, DiagnosticProviderShape];
-}