@rho-workspace/rho 0.5.2 → 0.5.3

package/node_modules/vscode-jsonrpc/lib/common/cancellation.d.ts

@@ -1,32 +0,0 @@
-import { Event } from './events';
-import { Disposable } from './disposable';
-/**
- * Defines a CancellationToken. This interface is not
- * intended to be implemented. A CancellationToken must
- * be created via a CancellationTokenSource.
- */
-export interface CancellationToken {
-    /**
-     * Is `true` when the token has been cancelled, `false` otherwise.
-     */
-    readonly isCancellationRequested: boolean;
-    /**
-     * An {@link Event event} which fires upon cancellation.
-     */
-    readonly onCancellationRequested: Event<any>;
-}
-export declare namespace CancellationToken {
-    const None: CancellationToken;
-    const Cancelled: CancellationToken;
-    function is(value: any): value is CancellationToken;
-}
-export interface AbstractCancellationTokenSource extends Disposable {
-    token: CancellationToken;
-    cancel(): void;
-}
-export declare class CancellationTokenSource implements AbstractCancellationTokenSource {
-    private _token;
-    get token(): CancellationToken;
-    cancel(): void;
-    dispose(): void;
-}

package/node_modules/vscode-jsonrpc/lib/common/connection.d.ts

@@ -1,367 +0,0 @@
-/// <reference path="../../typings/thenable.d.ts" preserve="true" />
-import { Message, RequestMessage, RequestType, RequestType0, RequestType1, RequestType2, RequestType3, RequestType4, RequestType5, RequestType6, RequestType7, RequestType8, RequestType9, ResponseMessage, ResponseError, NotificationMessage, NotificationType, NotificationType0, NotificationType1, NotificationType2, NotificationType3, NotificationType4, NotificationType5, NotificationType6, NotificationType7, NotificationType8, NotificationType9, _EM, ParameterStructures } from './messages';
-import type { Disposable } from './disposable';
-import { Event } from './events';
-import { CancellationToken, AbstractCancellationTokenSource } from './cancellation';
-import { MessageReader } from './messageReader';
-import { MessageWriter } from './messageWriter';
-export type ProgressToken = number | string;
-export declare namespace ProgressToken {
-    function is(value: any): value is number | string;
-}
-interface ProgressParams<T> {
-    /**
-     * The progress token provided by the client or server.
-     */
-    token: ProgressToken;
-    /**
-     * The progress data.
-     */
-    value: T;
-}
-export declare class ProgressType<PR> {
-    /**
-     * Clients must not use these properties. They are here to ensure correct typing.
-     * in TypeScript
-     */
-    readonly __: [PR, _EM] | undefined;
-    readonly _pr: PR | undefined;
-    constructor();
-}
-export type RequestParam<P> = P extends null ? P | undefined : P;
-export type HandlerResult<R, E, _R = R extends null ? (R | undefined | void) : R> = _R | ResponseError<E> | Thenable<_R> | Thenable<ResponseError<E>> | Thenable<_R | ResponseError<E>>;
-export interface StarRequestHandler {
-    (method: string, params: any[] | object | undefined, token: CancellationToken): HandlerResult<any, any>;
-}
-export interface GenericRequestHandler<R, E> {
-    (...params: any[]): HandlerResult<R, E>;
-}
-export interface RequestHandler0<R, E> {
-    (token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler<P, R, E> {
-    (params: P, token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler1<P1, R, E> {
-    (p1: P1, token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler2<P1, P2, R, E> {
-    (p1: P1, p2: P2, token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler3<P1, P2, P3, R, E> {
-    (p1: P1, p2: P2, p3: P3, token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler4<P1, P2, P3, P4, R, E> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler5<P1, P2, P3, P4, P5, R, E> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler6<P1, P2, P3, P4, P5, P6, R, E> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler7<P1, P2, P3, P4, P5, P6, P7, R, E> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler8<P1, P2, P3, P4, P5, P6, P7, P8, R, E> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, token: CancellationToken): HandlerResult<R, E>;
-}
-export interface RequestHandler9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, token: CancellationToken): HandlerResult<R, E>;
-}
-export type NotificationResult = void | Promise<void>;
-export interface StarNotificationHandler {
-    (method: string, params: any[] | object | undefined): NotificationResult;
-}
-export interface GenericNotificationHandler {
-    (...params: any[]): NotificationResult;
-}
-export interface NotificationHandler0 {
-    (): NotificationResult;
-}
-export interface NotificationHandler<P> {
-    (params: P): NotificationResult;
-}
-export interface NotificationHandler1<P1> {
-    (p1: P1): NotificationResult;
-}
-export interface NotificationHandler2<P1, P2> {
-    (p1: P1, p2: P2): NotificationResult;
-}
-export interface NotificationHandler3<P1, P2, P3> {
-    (p1: P1, p2: P2, p3: P3): NotificationResult;
-}
-export interface NotificationHandler4<P1, P2, P3, P4> {
-    (p1: P1, p2: P2, p3: P3, p4: P4): NotificationResult;
-}
-export interface NotificationHandler5<P1, P2, P3, P4, P5> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5): NotificationResult;
-}
-export interface NotificationHandler6<P1, P2, P3, P4, P5, P6> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6): NotificationResult;
-}
-export interface NotificationHandler7<P1, P2, P3, P4, P5, P6, P7> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7): NotificationResult;
-}
-export interface NotificationHandler8<P1, P2, P3, P4, P5, P6, P7, P8> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8): NotificationResult;
-}
-export interface NotificationHandler9<P1, P2, P3, P4, P5, P6, P7, P8, P9> {
-    (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9): NotificationResult;
-}
-export interface Logger {
-    error(message: string): void;
-    warn(message: string): void;
-    info(message: string): void;
-    log(message: string): void;
-}
-export declare const NullLogger: Logger;
-export declare enum Trace {
-    Off = 0,
-    Messages = 1,
-    Compact = 2,
-    Verbose = 3
-}
-export declare namespace TraceValue {
-    /**
-     * Turn tracing off.
-     */
-    const Off: 'off';
-    /**
-     * Trace messages only.
-     */
-    const Messages: 'messages';
-    /**
-     * Compact message tracing.
-     */
-    const Compact: 'compact';
-    /**
-     * Verbose message tracing.
-     */
-    const Verbose: 'verbose';
-}
-export type TraceValue = 'off' | 'messages' | 'compact' | 'verbose';
-/**
- * @deprecated Use TraceValue instead
- */
-export declare const TraceValues: typeof TraceValue;
-export type TraceValues = TraceValue;
-export declare namespace Trace {
-    function fromString(value: string): Trace;
-    function toString(value: Trace): TraceValue;
-}
-export declare enum TraceFormat {
-    Text = "text",
-    JSON = "json"
-}
-export declare namespace TraceFormat {
-    function fromString(value: string): TraceFormat;
-}
-export interface TraceOptions {
-    sendNotification?: boolean;
-    traceFormat?: TraceFormat;
-}
-export interface SetTraceParams {
-    value: TraceValue;
-}
-export declare namespace SetTraceNotification {
-    const type: NotificationType<SetTraceParams>;
-}
-export interface LogTraceParams {
-    message: string;
-    verbose?: string;
-}
-export declare namespace LogTraceNotification {
-    const type: NotificationType<LogTraceParams>;
-}
-export interface Tracer {
-    log(dataObject: any): void;
-    log(message: string, data?: string): void;
-}
-export declare enum ConnectionErrors {
-    /**
-     * The connection is closed.
-     */
-    Closed = 1,
-    /**
-     * The connection got disposed.
-     */
-    Disposed = 2,
-    /**
-     * The connection is already in listening mode.
-     */
-    AlreadyListening = 3
-}
-export declare class ConnectionError extends Error {
-    readonly code: ConnectionErrors;
-    constructor(code: ConnectionErrors, message: string);
-}
-export type ConnectionStrategy = {
-    cancelUndispatched?: (message: Message, next: (message: Message) => ResponseMessage | undefined) => ResponseMessage | undefined;
-};
-export declare namespace ConnectionStrategy {
-    function is(value: any): value is ConnectionStrategy;
-}
-export type CancellationId = number | string;
-export interface IdCancellationReceiverStrategy {
-    kind?: 'id';
-    /**
-     * Creates a CancellationTokenSource from a cancellation id.
-     *
-     * @param id The cancellation id.
-     */
-    createCancellationTokenSource(id: CancellationId): AbstractCancellationTokenSource;
-    /**
-     * An optional method to dispose the strategy.
-     */
-    dispose?(): void;
-}
-export declare namespace IdCancellationReceiverStrategy {
-    function is(value: any): value is IdCancellationReceiverStrategy;
-}
-export interface RequestCancellationReceiverStrategy {
-    kind: 'request';
-    /**
-     * Create a cancellation token source from a given request message.
-     *
-     * @param requestMessage The request message.
-     */
-    createCancellationTokenSource(requestMessage: RequestMessage): AbstractCancellationTokenSource;
-    /**
-     * An optional method to dispose the strategy.
-     */
-    dispose?(): void;
-}
-export declare namespace RequestCancellationReceiverStrategy {
-    function is(value: any): value is RequestCancellationReceiverStrategy;
-}
-export type CancellationReceiverStrategy = IdCancellationReceiverStrategy | RequestCancellationReceiverStrategy;
-export declare namespace CancellationReceiverStrategy {
-    const Message: CancellationReceiverStrategy;
-    function is(value: any): value is CancellationReceiverStrategy;
-}
-export interface CancellationSenderStrategy {
-    /**
-     * Hook to enable cancellation for the given request.
-     *
-     * @param request The request to enable cancellation for.
-     */
-    enableCancellation?(request: RequestMessage): void;
-    /**
-     * Send cancellation for the given cancellation id
-     *
-     * @param conn The connection used.
-     * @param id The cancellation id.
-     */
-    sendCancellation(conn: MessageConnection, id: CancellationId): Promise<void>;
-    /**
-     * Cleanup any cancellation state for the given cancellation id. After this
-     * method has been call no cancellation will be sent anymore for the given id.
-     *
-     * @param id The cancellation id.
-     */
-    cleanup(id: CancellationId): void;
-    /**
-     * An optional method to dispose the strategy.
-     */
-    dispose?(): void;
-}
-export declare namespace CancellationSenderStrategy {
-    const Message: CancellationSenderStrategy;
-    function is(value: any): value is CancellationSenderStrategy;
-}
-export interface CancellationStrategy {
-    receiver: CancellationReceiverStrategy | RequestCancellationReceiverStrategy;
-    sender: CancellationSenderStrategy;
-}
-export declare namespace CancellationStrategy {
-    const Message: CancellationStrategy;
-    function is(value: any): value is CancellationStrategy;
-}
-export interface MessageStrategy {
-    handleMessage(message: Message, next: (message: Message) => NotificationResult): NotificationResult;
-}
-export declare namespace MessageStrategy {
-    function is(value: any): value is MessageStrategy;
-}
-/**
- * Connection options. A valid connection option must have at least a
- * `CancellationStrategy` or a `MessageStrategy` or a `ConnectionStrategy`.
- */
-export interface ConnectionOptions {
-    cancellationStrategy?: CancellationStrategy;
-    connectionStrategy?: ConnectionStrategy;
-    messageStrategy?: MessageStrategy;
-    maxParallelism?: number;
-}
-export declare namespace ConnectionOptions {
-    function is(value: any): value is ConnectionOptions;
-}
-export interface MessageConnection {
-    sendRequest<R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>;
-    sendRequest<P, R, E>(type: RequestType<P, R, E>, params: NoInfer<RequestParam<P>>, token?: CancellationToken): Promise<R>;
-    sendRequest<P1, R, E>(type: RequestType1<P1, R, E>, p1: NoInfer<RequestParam<P1>>, token?: CancellationToken): Promise<R>;
-    sendRequest<P1, P2, R, E>(type: RequestType2<P1, P2, R, E>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, token?: CancellationToken): Promise<R>;
-    sendRequest<P1, P2, P3, R, E>(type: RequestType3<P1, P2, P3, R, E>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, token?: CancellationToken): Promise<R>;
-    sendRequest<P1, P2, P3, P4, R, E>(type: RequestType4<P1, P2, P3, P4, R, E>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, token?: CancellationToken): Promise<R>;
-    sendRequest<P1, P2, P3, P4, P5, R, E>(type: RequestType5<P1, P2, P3, P4, P5, R, E>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>, token?: CancellationToken): Promise<R>;
-    sendRequest<P1, P2, P3, P4, P5, P6, R, E>(type: RequestType6<P1, P2, P3, P4, P5, P6, R, E>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>, p6: NoInfer<RequestParam<P6>>, token?: CancellationToken): Promise<R>;
-    sendRequest<P1, P2, P3, P4, P5, P6, P7, R, E>(type: RequestType7<P1, P2, P3, P4, P5, P6, P7, R, E>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>, p6: NoInfer<RequestParam<P6>>, p7: NoInfer<RequestParam<P7>>, token?: CancellationToken): Promise<R>;
-    sendRequest<P1, P2, P3, P4, P5, P6, P7, P8, R, E>(type: RequestType8<P1, P2, P3, P4, P5, P6, P7, P8, R, E>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>, p6: NoInfer<RequestParam<P6>>, p7: NoInfer<RequestParam<P7>>, p8: NoInfer<RequestParam<P8>>, token?: CancellationToken): Promise<R>;
-    sendRequest<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E>(type: RequestType9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>, p6: NoInfer<RequestParam<P6>>, p7: NoInfer<RequestParam<P7>>, p8: NoInfer<RequestParam<P8>>, p9: NoInfer<RequestParam<P9>>, token?: CancellationToken): Promise<R>;
-    sendRequest<R>(method: string, r0?: ParameterStructures | any, ...rest: any[]): Promise<R>;
-    onRequest<R, E>(type: RequestType0<R, E>, handler: NoInfer<RequestHandler0<R, E>>): Disposable;
-    onRequest<P, R, E>(type: RequestType<P, R, E>, handler: NoInfer<RequestHandler<P, R, E>>): Disposable;
-    onRequest<P1, R, E>(type: RequestType1<P1, R, E>, handler: NoInfer<RequestHandler1<P1, R, E>>): Disposable;
-    onRequest<P1, P2, R, E>(type: RequestType2<P1, P2, R, E>, handler: NoInfer<RequestHandler2<P1, P2, R, E>>): Disposable;
-    onRequest<P1, P2, P3, R, E>(type: RequestType3<P1, P2, P3, R, E>, handler: NoInfer<RequestHandler3<P1, P2, P3, R, E>>): Disposable;
-    onRequest<P1, P2, P3, P4, R, E>(type: RequestType4<P1, P2, P3, P4, R, E>, handler: NoInfer<RequestHandler4<P1, P2, P3, P4, R, E>>): Disposable;
-    onRequest<P1, P2, P3, P4, P5, R, E>(type: RequestType5<P1, P2, P3, P4, P5, R, E>, handler: NoInfer<RequestHandler5<P1, P2, P3, P4, P5, R, E>>): Disposable;
-    onRequest<P1, P2, P3, P4, P5, P6, R, E>(type: RequestType6<P1, P2, P3, P4, P5, P6, R, E>, handler: NoInfer<RequestHandler6<P1, P2, P3, P4, P5, P6, R, E>>): Disposable;
-    onRequest<P1, P2, P3, P4, P5, P6, P7, R, E>(type: RequestType7<P1, P2, P3, P4, P5, P6, P7, R, E>, handler: NoInfer<RequestHandler7<P1, P2, P3, P4, P5, P6, P7, R, E>>): Disposable;
-    onRequest<P1, P2, P3, P4, P5, P6, P7, P8, R, E>(type: RequestType8<P1, P2, P3, P4, P5, P6, P7, P8, R, E>, handler: NoInfer<RequestHandler8<P1, P2, P3, P4, P5, P6, P7, P8, R, E>>): Disposable;
-    onRequest<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E>(type: RequestType9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E>, handler: NoInfer<RequestHandler9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R, E>>): Disposable;
-    onRequest<R, E>(method: string, handler: GenericRequestHandler<R, E>): Disposable;
-    onRequest(handler: StarRequestHandler): Disposable;
-    hasPendingResponse(): boolean;
-    sendNotification(type: NotificationType0): Promise<void>;
-    sendNotification<P>(type: NotificationType<P>, params?: NoInfer<RequestParam<P>>): Promise<void>;
-    sendNotification<P1>(type: NotificationType1<P1>, p1: NoInfer<RequestParam<P1>>): Promise<void>;
-    sendNotification<P1, P2>(type: NotificationType2<P1, P2>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>): Promise<void>;
-    sendNotification<P1, P2, P3>(type: NotificationType3<P1, P2, P3>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>): Promise<void>;
-    sendNotification<P1, P2, P3, P4>(type: NotificationType4<P1, P2, P3, P4>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>): Promise<void>;
-    sendNotification<P1, P2, P3, P4, P5>(type: NotificationType5<P1, P2, P3, P4, P5>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>): Promise<void>;
-    sendNotification<P1, P2, P3, P4, P5, P6>(type: NotificationType6<P1, P2, P3, P4, P5, P6>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>, p6: NoInfer<RequestParam<P6>>): Promise<void>;
-    sendNotification<P1, P2, P3, P4, P5, P6, P7>(type: NotificationType7<P1, P2, P3, P4, P5, P6, P7>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>, p6: NoInfer<RequestParam<P6>>, p7: NoInfer<RequestParam<P7>>): Promise<void>;
-    sendNotification<P1, P2, P3, P4, P5, P6, P7, P8>(type: NotificationType8<P1, P2, P3, P4, P5, P6, P7, P8>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>, p6: NoInfer<RequestParam<P6>>, p7: NoInfer<RequestParam<P7>>, p8: NoInfer<RequestParam<P8>>): Promise<void>;
-    sendNotification<P1, P2, P3, P4, P5, P6, P7, P8, P9>(type: NotificationType9<P1, P2, P3, P4, P5, P6, P7, P8, P9>, p1: NoInfer<RequestParam<P1>>, p2: NoInfer<RequestParam<P2>>, p3: NoInfer<RequestParam<P3>>, p4: NoInfer<RequestParam<P4>>, p5: NoInfer<RequestParam<P5>>, p6: NoInfer<RequestParam<P6>>, p7: NoInfer<RequestParam<P7>>, p8: NoInfer<RequestParam<P8>>, p9: NoInfer<RequestParam<P9>>): Promise<void>;
-    sendNotification(method: string, r0?: ParameterStructures | any, ...rest: any[]): Promise<void>;
-    onNotification(type: NotificationType0, handler: NotificationHandler0): Disposable;
-    onNotification<P>(type: NotificationType<P>, handler: NoInfer<NotificationHandler<P>>): Disposable;
-    onNotification<P1>(type: NotificationType1<P1>, handler: NoInfer<NotificationHandler1<P1>>): Disposable;
-    onNotification<P1, P2>(type: NotificationType2<P1, P2>, handler: NoInfer<NotificationHandler2<P1, P2>>): Disposable;
-    onNotification<P1, P2, P3>(type: NotificationType3<P1, P2, P3>, handler: NoInfer<NotificationHandler3<P1, P2, P3>>): Disposable;
-    onNotification<P1, P2, P3, P4>(type: NotificationType4<P1, P2, P3, P4>, handler: NoInfer<NotificationHandler4<P1, P2, P3, P4>>): Disposable;
-    onNotification<P1, P2, P3, P4, P5>(type: NotificationType5<P1, P2, P3, P4, P5>, handler: NoInfer<NotificationHandler5<P1, P2, P3, P4, P5>>): Disposable;
-    onNotification<P1, P2, P3, P4, P5, P6>(type: NotificationType6<P1, P2, P3, P4, P5, P6>, handler: NoInfer<NotificationHandler6<P1, P2, P3, P4, P5, P6>>): Disposable;
-    onNotification<P1, P2, P3, P4, P5, P6, P7>(type: NotificationType7<P1, P2, P3, P4, P5, P6, P7>, handler: NoInfer<NotificationHandler7<P1, P2, P3, P4, P5, P6, P7>>): Disposable;
-    onNotification<P1, P2, P3, P4, P5, P6, P7, P8>(type: NotificationType8<P1, P2, P3, P4, P5, P6, P7, P8>, handler: NoInfer<NotificationHandler8<P1, P2, P3, P4, P5, P6, P7, P8>>): Disposable;
-    onNotification<P1, P2, P3, P4, P5, P6, P7, P8, P9>(type: NotificationType9<P1, P2, P3, P4, P5, P6, P7, P8, P9>, handler: NoInfer<NotificationHandler9<P1, P2, P3, P4, P5, P6, P7, P8, P9>>): Disposable;
-    onNotification(method: string, handler: GenericNotificationHandler): Disposable;
-    onNotification(handler: StarNotificationHandler): Disposable;
-    onUnhandledNotification: Event<NotificationMessage>;
-    onProgress<P>(type: ProgressType<P>, token: string | number, handler: NoInfer<NotificationHandler<P>>): Disposable;
-    sendProgress<P>(type: ProgressType<P>, token: string | number, value: NoInfer<RequestParam<P>>): Promise<void>;
-    onUnhandledProgress: Event<ProgressParams<any>>;
-    trace(value: Trace, tracer: Tracer, sendNotification?: boolean): Promise<void>;
-    trace(value: Trace, tracer: Tracer, traceOptions?: TraceOptions): Promise<void>;
-    onError: Event<[Error, Message | undefined, number | undefined]>;
-    onClose: Event<void>;
-    listen(): void;
-    end(): void;
-    onDispose: Event<void>;
-    dispose(): void;
-    inspect(): void;
-}
-export declare function createMessageConnection(messageReader: MessageReader, messageWriter: MessageWriter, _logger?: Logger, options?: ConnectionOptions): MessageConnection;
-export {};

package/node_modules/vscode-jsonrpc/lib/common/disposable.d.ts

@@ -1,9 +0,0 @@
-export interface Disposable {
-    /**
-     * Dispose this object.
-     */
-    dispose(): void;
-}
-export declare namespace Disposable {
-    function create(func: () => void): Disposable;
-}

package/node_modules/vscode-jsonrpc/lib/common/encoding.d.ts

@@ -1,52 +0,0 @@
-import type RAL from './ral';
-import { Message } from './messages';
-export interface FunctionContentEncoder {
-    name: string;
-    encode(input: Uint8Array): Promise<Uint8Array>;
-}
-export interface StreamContentEncoder {
-    name: string;
-    create(): RAL.WritableStream;
-}
-export type ContentEncoder = FunctionContentEncoder | (FunctionContentEncoder & StreamContentEncoder);
-export interface FunctionContentDecoder {
-    name: string;
-    decode(buffer: Uint8Array): Promise<Uint8Array>;
-}
-export interface StreamContentDecoder {
-    name: string;
-    create(): RAL.WritableStream;
-}
-export type ContentDecoder = FunctionContentDecoder | (FunctionContentDecoder & StreamContentDecoder);
-export interface ContentTypeEncoderOptions {
-    charset: RAL.MessageBufferEncoding;
-}
-export interface FunctionContentTypeEncoder {
-    name: string;
-    encode(msg: Message, options: ContentTypeEncoderOptions): Promise<Uint8Array>;
-}
-export interface StreamContentTypeEncoder {
-    name: string;
-    create(options: ContentTypeEncoderOptions): RAL.WritableStream;
-}
-export type ContentTypeEncoder = FunctionContentTypeEncoder | (FunctionContentTypeEncoder & StreamContentTypeEncoder);
-export interface ContentTypeDecoderOptions {
-    charset: RAL.MessageBufferEncoding;
-}
-export interface FunctionContentTypeDecoder {
-    name: string;
-    decode(buffer: Uint8Array, options: ContentTypeDecoderOptions): Promise<Message>;
-}
-export interface StreamContentTypeDecoder {
-    name: string;
-    create(options: ContentTypeDecoderOptions): RAL.WritableStream;
-}
-export type ContentTypeDecoder = FunctionContentTypeDecoder | (FunctionContentTypeDecoder & StreamContentTypeDecoder);
-interface Named {
-    name: string;
-}
-export declare namespace Encodings {
-    function getEncodingHeaderValue(encodings: Named[]): string | undefined;
-    function parseEncodingHeaderValue(value: string): string[];
-}
-export {};

package/node_modules/vscode-jsonrpc/lib/common/events.d.ts

@@ -1,39 +0,0 @@
-import { Disposable } from './disposable';
-/**
- * Represents a typed event.
- */
-export interface Event<T> {
-    /**
-     *
-     * @param listener The listener function will be called when the event happens.
-     * @param thisArgs The 'this' which will be used when calling the event listener.
-     * @param disposables An array to which a {{IDisposable}} will be added.
-     * @return
-    */
-    (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]): Disposable;
-}
-export declare namespace Event {
-    const None: Event<any>;
-}
-export interface EmitterOptions {
-    onFirstListenerAdd?: Function;
-    onLastListenerRemove?: Function;
-}
-export declare class Emitter<T> {
-    private _options?;
-    private static _noop;
-    private _event;
-    private _callbacks;
-    constructor(_options?: EmitterOptions | undefined);
-    /**
-     * For the public to allow to subscribe
-     * to events from this Emitter
-     */
-    get event(): Event<T>;
-    /**
-     * To be kept private to fire an event to
-     * subscribers
-     */
-    fire(event: T): any;
-    dispose(): void;
-}

package/node_modules/vscode-jsonrpc/lib/common/is.d.ts

@@ -1,7 +0,0 @@
-export declare function boolean(value: any): value is boolean;
-export declare function string(value: any): value is string;
-export declare function number(value: any): value is number;
-export declare function error(value: any): value is Error;
-export declare function func(value: any): value is Function;
-export declare function array<T>(value: any): value is T[];
-export declare function stringArray(value: any): value is string[];

package/node_modules/vscode-jsonrpc/lib/common/linkedMap.d.ts

@@ -1,55 +0,0 @@
-export declare namespace Touch {
-    const None: 0;
-    const First: 1;
-    const AsOld: 1;
-    const Last: 2;
-    const AsNew: 2;
-}
-export type Touch = 0 | 1 | 2;
-export declare class LinkedMap<K, V> {
-    readonly [Symbol.toStringTag] = "LinkedMap";
-    private _map;
-    private _head;
-    private _tail;
-    private _size;
-    private _state;
-    constructor();
-    clear(): void;
-    isEmpty(): boolean;
-    get size(): number;
-    get first(): V | undefined;
-    get last(): V | undefined;
-    before(key: K): V | undefined;
-    after(key: K): V | undefined;
-    has(key: K): boolean;
-    get(key: K, touch?: Touch): V | undefined;
-    set(key: K, value: V, touch?: Touch): this;
-    delete(key: K): boolean;
-    remove(key: K): V | undefined;
-    shift(): V | undefined;
-    forEach(callbackfn: (value: V, key: K, map: LinkedMap<K, V>) => void, thisArg?: any): void;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    entries(): IterableIterator<[K, V]>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    protected trimOld(newSize: number): void;
-    private addItemFirst;
-    private addItemLast;
-    private removeItem;
-    private touch;
-    toJSON(): [K, V][];
-    fromJSON(data: [K, V][]): void;
-}
-export declare class LRUCache<K, V> extends LinkedMap<K, V> {
-    private _limit;
-    private _ratio;
-    constructor(limit: number, ratio?: number);
-    get limit(): number;
-    set limit(limit: number);
-    get ratio(): number;
-    set ratio(ratio: number);
-    get(key: K, touch?: Touch): V | undefined;
-    peek(key: K): V | undefined;
-    set(key: K, value: V): this;
-    private checkTrim;
-}

package/node_modules/vscode-jsonrpc/lib/common/messageBuffer.d.ts

@@ -1,18 +0,0 @@
-import RAL from './ral';
-export declare abstract class AbstractMessageBuffer implements RAL.MessageBuffer {
-    private _encoding;
-    private _chunks;
-    private _totalLength;
-    constructor(encoding?: RAL.MessageBufferEncoding);
-    protected abstract emptyBuffer(): Uint8Array;
-    protected abstract fromString(value: string, encoding: RAL.MessageBufferEncoding): Uint8Array;
-    protected abstract toString(value: Uint8Array, encoding: RAL.MessageBufferEncoding): string;
-    protected abstract asNative(buffer: Uint8Array, length?: number): Uint8Array;
-    protected abstract allocNative(length: number): Uint8Array;
-    get encoding(): RAL.MessageBufferEncoding;
-    append(chunk: Uint8Array | string): void;
-    tryReadHeaders(lowerCaseKeys?: boolean): Map<string, string> | undefined;
-    tryReadBody(length: number): Uint8Array | undefined;
-    get numberOfBytes(): number;
-    private _read;
-}

package/node_modules/vscode-jsonrpc/lib/common/messageReader.d.ts

@@ -1,77 +0,0 @@
-import RAL from './ral';
-import { Event } from './events';
-import { Message } from './messages';
-import { ContentDecoder, ContentTypeDecoder } from './encoding';
-import { Disposable } from './api';
-/**
- * A callback that receives each incoming JSON-RPC message.
- */
-export interface DataCallback {
-    (data: Message): void;
-}
-export interface PartialMessageInfo {
-    readonly messageToken: number;
-    readonly waitingTime: number;
-}
-/** Reads JSON-RPC messages from some underlying transport. */
-export interface MessageReader {
-    /** Raised whenever an error occurs while reading a message. */
-    readonly onError: Event<Error>;
-    /** An event raised when the end of the underlying transport has been reached. */
-    readonly onClose: Event<void>;
-    /**
-     * An event that *may* be raised to inform the owner that only part of a message has been received.
-     * A MessageReader implementation may choose to raise this event after a timeout elapses while waiting for more of a partially received message to be received.
-     */
-    readonly onPartialMessage: Event<PartialMessageInfo>;
-    /**
-     * Begins listening for incoming messages. To be called at most once.
-     * @param callback A callback for receiving decoded messages.
-     */
-    listen(callback: DataCallback): Disposable;
-    /** Releases resources incurred from reading or raising events. Does NOT close the underlying transport, if any. */
-    dispose(): void;
-}
-export declare namespace MessageReader {
-    function is(value: any): value is MessageReader;
-}
-export declare abstract class AbstractMessageReader implements MessageReader {
-    private errorEmitter;
-    private closeEmitter;
-    private partialMessageEmitter;
-    constructor();
-    dispose(): void;
-    get onError(): Event<Error>;
-    protected fireError(error: any): void;
-    get onClose(): Event<void>;
-    protected fireClose(): void;
-    get onPartialMessage(): Event<PartialMessageInfo>;
-    protected firePartialMessage(info: PartialMessageInfo): void;
-    private asError;
-    abstract listen(callback: DataCallback): Disposable;
-}
-export interface MessageReaderOptions {
-    charset?: RAL.MessageBufferEncoding;
-    contentDecoder?: ContentDecoder;
-    contentDecoders?: ContentDecoder[];
-    contentTypeDecoder?: ContentTypeDecoder;
-    contentTypeDecoders?: ContentTypeDecoder[];
-}
-export declare class ReadableStreamMessageReader extends AbstractMessageReader {
-    private readable;
-    private options;
-    private callback;
-    private nextMessageLength;
-    private messageToken;
-    private buffer;
-    private partialMessageTimer;
-    private _partialMessageTimeout;
-    private readSemaphore;
-    constructor(readable: RAL.ReadableStream, options?: RAL.MessageBufferEncoding | MessageReaderOptions);
-    set partialMessageTimeout(timeout: number);
-    get partialMessageTimeout(): number;
-    listen(callback: DataCallback): Disposable;
-    private onData;
-    private clearPartialMessageTimer;
-    private setPartialMessageTimer;
-}