Initial commit

node_modules/json-rpc-2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Shogo Wada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/json-rpc-2.0/README.md

@@ -0,0 +1,492 @@
+# json-rpc-2.0
+
+Let your client and server talk over function calls under [JSON-RPC 2.0 spec](https://www.jsonrpc.org/specification).
+
+- Protocol agnostic
+  - Use over HTTP, WebSocket, TCP, UDP, inter-process, whatever else
+    - Easy migration from HTTP to WebSocket, for example
+- No external dependencies
+  - Keep your package small
+  - Stay away from dependency hell
+- Works in both browser and Node.js
+- First-class TypeScript support
+  - Written in TypeScript
+  - [Strongly typed client and server calls](#typed-client-and-server)
+
+## Install
+
+`npm install --save json-rpc-2.0`
+
+## Example
+
+The example uses HTTP for communication protocol, but it can be anything.
+
+### Server
+
+```javascript
+const express = require("express");
+const bodyParser = require("body-parser");
+const { JSONRPCServer } = require("json-rpc-2.0");
+
+const server = new JSONRPCServer();
+
+// First parameter is a method name.
+// Second parameter is a method itself.
+// A method takes JSON-RPC params and returns a result.
+// It can also return a promise of the result.
+server.addMethod("echo", ({ text }) => text);
+server.addMethod("log", ({ message }) => console.log(message));
+
+const app = express();
+app.use(bodyParser.json());
+
+app.post("/json-rpc", (req, res) => {
+  const jsonRPCRequest = req.body;
+  // server.receive takes a JSON-RPC request and returns a promise of a JSON-RPC response.
+  // It can also receive an array of requests, in which case it may return an array of responses.
+  // Alternatively, you can use server.receiveJSON, which takes JSON string as is (in this case req.body).
+  server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+    if (jsonRPCResponse) {
+      res.json(jsonRPCResponse);
+    } else {
+      // If response is absent, it was a JSON-RPC notification method.
+      // Respond with no content status (204).
+      res.sendStatus(204);
+    }
+  });
+});
+
+app.listen(80);
+```
+
+#### With authentication
+
+To hook authentication into the API, inject custom params:
+
+```javascript
+const server = new JSONRPCServer();
+
+// The method can also take a custom parameter as the second parameter.
+// Use this to inject whatever information that method needs outside the regular JSON-RPC request.
+server.addMethod("echo", ({ text }, { userID }) => `${userID} said ${text}`);
+
+app.post("/json-rpc", (req, res) => {
+  const jsonRPCRequest = req.body;
+  const userID = getUserID(req);
+
+  // server.receive takes an optional second parameter.
+  // The parameter will be injected to the JSON-RPC method as the second parameter.
+  server.receive(jsonRPCRequest, { userID }).then((jsonRPCResponse) => {
+    if (jsonRPCResponse) {
+      res.json(jsonRPCResponse);
+    } else {
+      res.sendStatus(204);
+    }
+  });
+});
+
+const getUserID = (req) => {
+  // Do whatever to get user ID out of the request
+};
+```
+
+#### Middleware
+
+Use middleware to intercept request and response:
+
+```javascript
+const server = new JSONRPCServer();
+
+// next will call the next middleware
+const logMiddleware = (next, request, serverParams) => {
+  console.log(`Received ${JSON.stringify(request)}`);
+  return next(request, serverParams).then((response) => {
+    console.log(`Responding ${JSON.stringify(response)}`);
+    return response;
+  });
+};
+
+const exceptionMiddleware = async (next, request, serverParams) => {
+  try {
+    return await next(request, serverParams);
+  } catch (error) {
+    if (error.code) {
+      return createJSONRPCErrorResponse(request.id, error.code, error.message);
+    } else {
+      throw error;
+    }
+  }
+};
+
+// Middleware will be called in the same order they are applied
+server.applyMiddleware(logMiddleware, exceptionMiddleware);
+```
+
+#### Constructor Options
+
+Optionally, you can pass options to `JSONRPCServer` constructor:
+
+```typescript
+new JSONRPCServer({
+  errorListener: (message: string, data: unknown): void => {
+    // Listen to error here. By default, it will use console.warn to log errors.
+  },
+});
+```
+
+### Client
+
+```javascript
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// JSONRPCClient needs to know how to send a JSON-RPC request.
+// Tell it by passing a function to its constructor. The function must take a JSON-RPC request and send it.
+const client = new JSONRPCClient((jsonRPCRequest) =>
+  fetch("http://localhost/json-rpc", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(jsonRPCRequest),
+  }).then((response) => {
+    if (response.status === 200) {
+      // Use client.receive when you received a JSON-RPC response.
+      return response
+        .json()
+        .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+    } else if (jsonRPCRequest.id !== undefined) {
+      return Promise.reject(new Error(response.statusText));
+    }
+  })
+);
+
+// Use client.request to make a JSON-RPC request call.
+// The function returns a promise of the result.
+client
+  .request("echo", { text: "Hello, World!" })
+  .then((result) => console.log(result));
+
+// Use client.notify to make a JSON-RPC notification call.
+// By definition, JSON-RPC notification does not respond.
+client.notify("log", { message: "Hello, World!" });
+```
+
+#### With authentication
+
+Just like `JSONRPCServer`, you can inject custom params to `JSONRPCClient` too:
+
+```javascript
+const client = new JSONRPCClient(
+  // It can also take a custom parameter as the second parameter.
+  (jsonRPCRequest, { token }) =>
+    fetch("http://localhost/json-rpc", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`, // Use the passed token
+      },
+      body: JSON.stringify(jsonRPCRequest),
+    }).then((response) => {
+      // ...
+    })
+);
+
+// Pass the custom params as the third argument.
+client.request("echo", { text: "Hello, World!" }, { token: "foo's token" });
+client.notify("log", { message: "Hello, World!" }, { token: "foo's token" });
+```
+
+#### With timeout
+
+Sometimes you don't want to wait for the response indefinitely. You can use `timeout` to automatically fail the request after certain delay:
+
+```typescript
+const client = new JSONRPCClient(/* ... */);
+
+client
+  .timeout(10 * 1000) // Automatically fails if it didn't get a response within 10 sec
+  .request("echo", { text: "Hello, World!" });
+
+// Create a custom error response
+const createTimeoutJSONRPCErrorResponse = (
+  id: JSONRPCID
+): JSONRPCErrorResponse =>
+  createJSONRPCErrorResponse(id, 123, "Custom error message");
+
+client
+  .timeout(10 * 1000, createTimeoutJSONRPCErrorResponse)
+  .request("echo", { text: "Hello, World!" });
+```
+
+### Bi-directional JSON-RPC
+
+For bi-directional JSON-RPC, use `JSONRPCServerAndClient`.
+
+```javascript
+const webSocket = new WebSocket("ws://localhost");
+
+const serverAndClient = new JSONRPCServerAndClient(
+  new JSONRPCServer(),
+  new JSONRPCClient((request) => {
+    try {
+      webSocket.send(JSON.stringify(request));
+      return Promise.resolve();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  })
+);
+
+webSocket.onmessage = (event) => {
+  serverAndClient.receiveAndSend(JSON.parse(event.data.toString()));
+};
+
+// On close, make sure to reject all the pending requests to prevent hanging.
+webSocket.onclose = (event) => {
+  serverAndClient.rejectAllPendingRequests(
+    `Connection is closed (${event.reason}).`
+  );
+};
+
+serverAndClient.addMethod("echo", ({ text }) => text);
+
+serverAndClient
+  .request("add", { x: 1, y: 2 })
+  .then((result) => console.log(`1 + 2 = ${result}`));
+```
+
+#### Constructor Options
+
+Optionally, you can pass options to `JSONRPCServerAndClient` constructor:
+
+```typescript
+new JSONRPCServerAndClient(server, client, {
+  errorListener: (message: string, data: unknown): void => {
+    // Listen to error here. By default, it will use console.warn to log errors.
+  },
+});
+```
+
+### Error handling
+
+To respond an error, reject with an `Error`. On the client side, the promise will be rejected with an `Error` object with the same message.
+
+```javascript
+server.addMethod("fail", () =>
+  Promise.reject(new Error("This is an error message."))
+);
+
+client.request("fail").then(
+  () => console.log("This does not get called"),
+  (error) => console.error(error.message) // Outputs "This is an error message."
+);
+```
+
+If you want to return a custom error response, use `JSONRPCErrorException`:
+
+```typescript
+import { JSONRPCErrorException } from "json-rpc-2.0";
+
+const server = new JSONRPCServer();
+
+server.addMethod("throws", () => {
+  const errorCode = 123;
+  const errorData = {
+    foo: "bar",
+  };
+
+  throw new JSONRPCErrorException(
+    "A human readable error message",
+    errorCode,
+    errorData
+  );
+});
+```
+
+Alternatively, use [advanced APIs](#advanced-apis) or implement `mapErrorToJSONRPCErrorResponse`:
+
+```typescript
+import {
+  createJSONRPCErrorResponse,
+  JSONRPCErrorResponse,
+  JSONRPCID,
+  JSONRPCServer,
+} from "json-rpc-2.0";
+
+const server = new JSONRPCServer();
+
+server.mapErrorToJSONRPCErrorResponse = (
+  id: JSONRPCID,
+  error: any
+): JSONRPCErrorResponse => {
+  return createJSONRPCErrorResponse(
+    id,
+    error?.code || 0,
+    error?.message || "An unexpected error occurred",
+    // Optional 4th argument. It maps to error.data of the response.
+    { foo: "bar" }
+  );
+};
+```
+
+### Advanced APIs
+
+Use the advanced APIs to handle raw JSON-RPC messages.
+
+#### Server
+
+```typescript
+import { JSONRPC, JSONRPCResponse, JSONRPCServer } from "json-rpc-2.0";
+
+const server = new JSONRPCServer();
+
+// Advanced method takes a raw JSON-RPC request and returns a raw JSON-RPC response
+server.addMethodAdvanced(
+  "doSomething",
+  (jsonRPCRequest: JSONRPCRequest): PromiseLike<JSONRPCResponse> => {
+    if (isValid(jsonRPCRequest.params)) {
+      return {
+        jsonrpc: JSONRPC,
+        id: jsonRPCRequest.id,
+        result: "Params are valid",
+      };
+    } else {
+      return {
+        jsonrpc: JSONRPC,
+        id: jsonRPCRequest.id,
+        error: {
+          code: -100,
+          message: "Params are invalid",
+          data: jsonRPCRequest.params,
+        },
+      };
+    }
+  }
+);
+
+// Remove the added method
+server.removeMethod("doSomething");
+```
+
+#### Client
+
+```typescript
+import {
+  JSONRPC,
+  JSONRPCClient,
+  JSONRPCRequest,
+  JSONRPCResponse,
+} from "json-rpc-2.0";
+
+const send = () => {
+  // ...
+};
+let nextID: number = 0;
+const createID = () => nextID++;
+
+// To avoid conflict ID between basic and advanced method request, inject a custom ID factory function.
+const client = new JSONRPCClient(send, createID);
+
+const jsonRPCRequest: JSONRPCRequest = {
+  jsonrpc: JSONRPC,
+  id: createID(),
+  method: "doSomething",
+  params: {
+    foo: "foo",
+    bar: "bar",
+  },
+};
+
+// Advanced method takes a raw JSON-RPC request and returns a raw JSON-RPC response
+// It can also send an array of requests, in which case it returns an array of responses.
+client
+  .requestAdvanced(jsonRPCRequest)
+  .then((jsonRPCResponse: JSONRPCResponse) => {
+    if (jsonRPCResponse.error) {
+      console.log(
+        `Received an error with code ${jsonRPCResponse.error.code} and message ${jsonRPCResponse.error.message}`
+      );
+    } else {
+      doSomethingWithResult(jsonRPCResponse.result);
+    }
+  });
+```
+
+### Typed client and server
+
+To strongly type `request` and `addMethod` methods, use `TypedJSONRPCClient`, `TypedJSONRPCServer` and `TypedJSONRPCServerAndClient` interfaces.
+
+```typescript
+import {
+  JSONRPCClient,
+  JSONRPCServer,
+  JSONRPCServerAndClient,
+  TypedJSONRPCClient,
+  TypedJSONRPCServer,
+  TypedJSONRPCServerAndClient,
+} from "json-rpc-2.0";
+
+type Methods = {
+  echo(params: { message: string }): string;
+  sum(params: { x: number; y: number }): number;
+};
+
+const server: TypedJSONRPCServer<Methods> = new JSONRPCServer(/* ... */);
+const client: TypedJSONRPCClient<Methods> = new JSONRPCClient(/* ... */);
+
+// Types are infered from the Methods type
+server.addMethod("echo", ({ message }) => message);
+server.addMethod("sum", ({ x, y }) => x + y);
+// These result in type error
+// server.addMethod("ech0", ({ message }) => message); // typo in method name
+// server.addMethod("echo", ({ messagE }) => messagE); // typo in param name
+// server.addMethod("echo", ({ message }) => 123); // return type must be string
+
+client
+  .request("echo", { message: "hello" })
+  .then((result) => console.log(result));
+client.request("sum", { x: 1, y: 2 }).then((result) => console.log(result));
+// These result in type error
+// client.request("ech0", { message: "hello" }); // typo in method name
+// client.request("echo", { messagE: "hello" }); // typo in param name
+// client.request("echo", { message: 123 }); // message param must be string
+// client
+//   .request("echo", { message: "hello" })
+//   .then((result: number) => console.log(result)); // return type must be string
+
+// The same rule applies to TypedJSONRPCServerAndClient
+type ServerAMethods = {
+  echo(params: { message: string }): string;
+};
+
+type ServerBMethods = {
+  sum(params: { x: number; y: number }): number;
+};
+
+const serverAndClientA: TypedJSONRPCServerAndClient<
+  ServerAMethods,
+  ServerBMethods
+> = new JSONRPCServerAndClient(/* ... */);
+const serverAndClientB: TypedJSONRPCServerAndClient<
+  ServerBMethods,
+  ServerAMethods
+> = new JSONRPCServerAndClient(/* ... */);
+
+serverAndClientA.addMethod("echo", ({ message }) => message);
+serverAndClientB.addMethod("sum", ({ x, y }) => x + y);
+
+serverAndClientA
+  .request("sum", { x: 1, y: 2 })
+  .then((result) => console.log(result));
+serverAndClientB
+  .request("echo", { message: "hello" })
+  .then((result) => console.log(result));
+```
+
+## Build
+
+`npm run build`
+
+## Test
+
+`npm test`

node_modules/json-rpc-2.0/dist/client.d.ts

@@ -0,0 +1,25 @@
+import { JSONRPCErrorResponse, JSONRPCID, JSONRPCParams, JSONRPCRequest, JSONRPCResponse } from "./models";
+export type SendRequest<ClientParams> = (payload: any, clientParams: ClientParams) => PromiseLike<void> | void;
+export type CreateID = () => JSONRPCID;
+export interface JSONRPCRequester<ClientParams> {
+    request(method: string, params?: JSONRPCParams, clientParams?: ClientParams): PromiseLike<any>;
+    requestAdvanced(request: JSONRPCRequest, clientParams?: ClientParams): PromiseLike<JSONRPCResponse>;
+    requestAdvanced(request: JSONRPCRequest[], clientParams?: ClientParams): PromiseLike<JSONRPCResponse[]>;
+}
+export declare class JSONRPCClient<ClientParams = void> implements JSONRPCRequester<ClientParams> {
+    private _send;
+    private createID?;
+    private idToResolveMap;
+    private id;
+    constructor(_send: SendRequest<ClientParams>, createID?: CreateID | undefined);
+    private _createID;
+    timeout(delay: number, overrideCreateJSONRPCErrorResponse?: (id: JSONRPCID) => JSONRPCErrorResponse): JSONRPCRequester<ClientParams>;
+    request(method: string, params: JSONRPCParams, clientParams: ClientParams): PromiseLike<any>;
+    private requestWithID;
+    requestAdvanced(request: JSONRPCRequest, clientParams: ClientParams): PromiseLike<JSONRPCResponse>;
+    requestAdvanced(request: JSONRPCRequest[], clientParams: ClientParams): PromiseLike<JSONRPCResponse[]>;
+    notify(method: string, params: JSONRPCParams, clientParams: ClientParams): void;
+    send(payload: any, clientParams: ClientParams): Promise<void>;
+    rejectAllPendingRequests(message: string): void;
+    receive(responses: JSONRPCResponse | JSONRPCResponse[]): void;
+}

node_modules/json-rpc-2.0/dist/client.js

@@ -0,0 +1,187 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONRPCClient = void 0;
+var models_1 = require("./models");
+var internal_1 = require("./internal");
+var JSONRPCClient = /** @class */ (function () {
+    function JSONRPCClient(_send, createID) {
+        this._send = _send;
+        this.createID = createID;
+        this.idToResolveMap = new Map();
+        this.id = 0;
+    }
+    JSONRPCClient.prototype._createID = function () {
+        if (this.createID) {
+            return this.createID();
+        }
+        else {
+            return ++this.id;
+        }
+    };
+    JSONRPCClient.prototype.timeout = function (delay, overrideCreateJSONRPCErrorResponse) {
+        var _this = this;
+        if (overrideCreateJSONRPCErrorResponse === void 0) { overrideCreateJSONRPCErrorResponse = function (id) {
+            return (0, models_1.createJSONRPCErrorResponse)(id, internal_1.DefaultErrorCode, "Request timeout");
+        }; }
+        var timeoutRequest = function (ids, request) {
+            var timeoutID = setTimeout(function () {
+                ids.forEach(function (id) {
+                    var resolve = _this.idToResolveMap.get(id);
+                    if (resolve) {
+                        _this.idToResolveMap.delete(id);
+                        resolve(overrideCreateJSONRPCErrorResponse(id));
+                    }
+                });
+            }, delay);
+            return request().then(function (result) {
+                clearTimeout(timeoutID);
+                return result;
+            }, function (error) {
+                clearTimeout(timeoutID);
+                return Promise.reject(error);
+            });
+        };
+        var requestAdvanced = function (request, clientParams) {
+            var ids = (!Array.isArray(request) ? [request] : request)
+                .map(function (request) { return request.id; })
+                .filter(isDefinedAndNonNull);
+            return timeoutRequest(ids, function () {
+                return _this.requestAdvanced(request, clientParams);
+            });
+        };
+        return {
+            request: function (method, params, clientParams) {
+                var id = _this._createID();
+                return timeoutRequest([id], function () {
+                    return _this.requestWithID(method, params, clientParams, id);
+                });
+            },
+            requestAdvanced: function (request, clientParams) { return requestAdvanced(request, clientParams); },
+        };
+    };
+    JSONRPCClient.prototype.request = function (method, params, clientParams) {
+        return this.requestWithID(method, params, clientParams, this._createID());
+    };
+    JSONRPCClient.prototype.requestWithID = function (method, params, clientParams, id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var request, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        request = (0, models_1.createJSONRPCRequest)(id, method, params);
+                        return [4 /*yield*/, this.requestAdvanced(request, clientParams)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.result !== undefined && !response.error) {
+                            return [2 /*return*/, response.result];
+                        }
+                        else if (response.result === undefined && response.error) {
+                            return [2 /*return*/, Promise.reject(new models_1.JSONRPCErrorException(response.error.message, response.error.code, response.error.data))];
+                        }
+                        else {
+                            return [2 /*return*/, Promise.reject(new Error("An unexpected error occurred"))];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    JSONRPCClient.prototype.requestAdvanced = function (requests, clientParams) {
+        var _this = this;
+        var areRequestsOriginallyArray = Array.isArray(requests);
+        if (!Array.isArray(requests)) {
+            requests = [requests];
+        }
+        var requestsWithID = requests.filter(function (request) {
+            return isDefinedAndNonNull(request.id);
+        });
+        var promises = requestsWithID.map(function (request) {
+            return new Promise(function (resolve) { return _this.idToResolveMap.set(request.id, resolve); });
+        });
+        var promise = Promise.all(promises).then(function (responses) {
+            if (areRequestsOriginallyArray || !responses.length) {
+                return responses;
+            }
+            else {
+                return responses[0];
+            }
+        });
+        return this.send(areRequestsOriginallyArray ? requests : requests[0], clientParams).then(function () { return promise; }, function (error) {
+            requestsWithID.forEach(function (request) {
+                _this.receive((0, models_1.createJSONRPCErrorResponse)(request.id, internal_1.DefaultErrorCode, (error && error.message) || "Failed to send a request"));
+            });
+            return promise;
+        });
+    };
+    JSONRPCClient.prototype.notify = function (method, params, clientParams) {
+        var request = (0, models_1.createJSONRPCNotification)(method, params);
+        this.send(request, clientParams).then(undefined, function () { return undefined; });
+    };
+    JSONRPCClient.prototype.send = function (payload, clientParams) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this._send(payload, clientParams)];
+            });
+        });
+    };
+    JSONRPCClient.prototype.rejectAllPendingRequests = function (message) {
+        this.idToResolveMap.forEach(function (resolve, id) {
+            return resolve((0, models_1.createJSONRPCErrorResponse)(id, internal_1.DefaultErrorCode, message));
+        });
+        this.idToResolveMap.clear();
+    };
+    JSONRPCClient.prototype.receive = function (responses) {
+        var _this = this;
+        if (!Array.isArray(responses)) {
+            responses = [responses];
+        }
+        responses.forEach(function (response) {
+            var resolve = _this.idToResolveMap.get(response.id);
+            if (resolve) {
+                _this.idToResolveMap.delete(response.id);
+                resolve(response);
+            }
+        });
+    };
+    return JSONRPCClient;
+}());
+exports.JSONRPCClient = JSONRPCClient;
+var isDefinedAndNonNull = function (value) {
+    return value !== undefined && value !== null;
+};

node_modules/json-rpc-2.0/dist/client.spec.d.ts

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

node_modules/json-rpc-2.0/dist/client.spec.js

@@ -0,0 +1,430 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mocha_1 = require("mocha");
+var chai_1 = require("chai");
+var sinon = require("sinon");
+var _1 = require(".");
+(0, mocha_1.describe)("JSONRPCClient", function () {
+    var client;
+    var id;
+    var lastRequest;
+    var lastClientParams;
+    var resolve;
+    var reject;
+    (0, mocha_1.beforeEach)(function () {
+        id = 0;
+        lastRequest = undefined;
+        resolve = undefined;
+        reject = undefined;
+        var send = function (request, clientParams) {
+            lastRequest = request;
+            lastClientParams = clientParams;
+            return new Promise(function (givenResolve, givenReject) {
+                resolve = givenResolve;
+                reject = givenReject;
+            });
+        };
+        client = new _1.JSONRPCClient(send, function () { return ++id; });
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    (0, mocha_1.describe)("requesting", function () {
+        var result;
+        var error;
+        var promise;
+        (0, mocha_1.beforeEach)(function () {
+            result = undefined;
+            error = undefined;
+            promise = client.request("foo", ["bar"], { token: "" }).then(function (givenResult) { return (result = givenResult); }, function (givenError) { return (error = givenError); });
+        });
+        (0, mocha_1.it)("should send the request", function () {
+            (0, chai_1.expect)(lastRequest).to.deep.equal({
+                jsonrpc: _1.JSONRPC,
+                id: id,
+                method: "foo",
+                params: ["bar"],
+            });
+        });
+        (0, mocha_1.describe)("succeeded on client side", function () {
+            (0, mocha_1.beforeEach)(function () {
+                resolve();
+            });
+            (0, mocha_1.describe)("and succeeded on server side too", function () {
+                var response;
+                (0, mocha_1.beforeEach)(function () {
+                    response = {
+                        jsonrpc: _1.JSONRPC,
+                        id: id,
+                        result: "foo",
+                    };
+                    client.receive(response);
+                    return promise;
+                });
+                (0, mocha_1.it)("should resolve the result", function () {
+                    (0, chai_1.expect)(result).to.equal(response.result);
+                });
+            });
+            (0, mocha_1.describe)("and succeeded on server side with falsy but defined result", function () {
+                (0, mocha_1.beforeEach)(function () {
+                    client.receive({
+                        jsonrpc: _1.JSONRPC,
+                        id: id,
+                        result: 0,
+                    });
+                    return promise;
+                });
+                (0, mocha_1.it)("should resolve the result", function () {
+                    (0, chai_1.expect)(result).to.equal(0);
+                });
+            });
+            (0, mocha_1.describe)("but failed on server side", function () {
+                var response;
+                (0, mocha_1.beforeEach)(function () {
+                    response = {
+                        jsonrpc: _1.JSONRPC,
+                        id: id,
+                        error: {
+                            code: 0,
+                            message: "This is a test. Do not panic.",
+                            data: { optional: "data" },
+                        },
+                    };
+                    client.receive(response);
+                    return promise;
+                });
+                (0, mocha_1.it)("should reject with the error message, code and data", function () {
+                    (0, chai_1.expect)(error.message).to.equal(response.error.message);
+                    (0, chai_1.expect)(error.code).to.equal(response.error.code);
+                    (0, chai_1.expect)(error.data).to.equal(response.error.data);
+                });
+                (0, mocha_1.it)("should reject with a JSONRPCErrorException", function () {
+                    (0, chai_1.expect)(error instanceof Error).to.be.true;
+                    (0, chai_1.expect)(error instanceof _1.JSONRPCErrorException).to.be.true;
+                    (0, chai_1.expect)(error.toObject()).to.deep.equal(response.error);
+                });
+            });
+            (0, mocha_1.describe)("but server responded invalid response", function () {
+                (0, mocha_1.describe)("like having both result and error", function () {
+                    var response;
+                    (0, mocha_1.beforeEach)(function () {
+                        response = {
+                            jsonrpc: _1.JSONRPC,
+                            id: id,
+                            result: "foo",
+                            error: {
+                                code: 0,
+                                message: "bar",
+                            },
+                        };
+                        client.receive(response);
+                        return promise;
+                    });
+                    (0, mocha_1.it)("should reject", function () {
+                        (0, chai_1.expect)(error).to.not.be.undefined;
+                    });
+                });
+                (0, mocha_1.describe)("like not having both result and error", function () {
+                    var response;
+                    (0, mocha_1.beforeEach)(function () {
+                        response = {
+                            jsonrpc: _1.JSONRPC,
+                            id: id,
+                        };
+                        client.receive(response);
+                        return promise;
+                    });
+                    (0, mocha_1.it)("should reject", function () {
+                        (0, chai_1.expect)(error).to.not.be.undefined;
+                    });
+                });
+            });
+            (0, mocha_1.describe)("but I reject all pending requests", function () {
+                var message;
+                (0, mocha_1.beforeEach)(function () {
+                    message = "Connection is closed.";
+                    client.rejectAllPendingRequests(message);
+                    return promise;
+                });
+                (0, mocha_1.it)("should reject the request", function () {
+                    (0, chai_1.expect)(error.message).to.equal(message);
+                });
+                (0, mocha_1.describe)("receiving a response", function () {
+                    (0, mocha_1.beforeEach)(function () {
+                        client.receive({
+                            jsonrpc: _1.JSONRPC,
+                            id: id,
+                            result: "foo",
+                        });
+                        return promise;
+                    });
+                    (0, mocha_1.it)("should not resolve the promise again", function () {
+                        (0, chai_1.expect)(result).to.be.undefined;
+                    });
+                });
+            });
+        });
+        (0, mocha_1.describe)("failed on client side", function () {
+            var expected;
+            (0, mocha_1.beforeEach)(function () {
+                expected = new Error("This is a test. Do not panic.");
+                reject(expected);
+                return promise;
+            });
+            (0, mocha_1.it)("should reject the promise", function () {
+                (0, chai_1.expect)(error.message).to.equal(expected.message);
+            });
+        });
+        (0, mocha_1.describe)("failed on client side with no error object", function () {
+            (0, mocha_1.beforeEach)(function () {
+                reject(undefined);
+                return promise;
+            });
+            (0, mocha_1.it)("should reject the promise", function () {
+                (0, chai_1.expect)(error.message).to.equal("Failed to send a request");
+            });
+        });
+        (0, mocha_1.describe)("failed on client side with an error object without message", function () {
+            (0, mocha_1.beforeEach)(function () {
+                reject({});
+                return promise;
+            });
+            (0, mocha_1.it)("should reject the promise", function () {
+                (0, chai_1.expect)(error.message).to.equal("Failed to send a request");
+            });
+        });
+    });
+    (0, mocha_1.describe)("requesting batch", function () {
+        var requests;
+        var actualResponses;
+        var expectedResponses;
+        (0, mocha_1.beforeEach)(function () {
+            requests = [
+                { jsonrpc: _1.JSONRPC, id: 0, method: "foo" },
+                { jsonrpc: _1.JSONRPC, id: 1, method: "foo2" },
+            ];
+            client
+                .requestAdvanced(requests, { token: "" })
+                .then(function (responses) { return (actualResponses = responses); });
+            resolve();
+            expectedResponses = [
+                { jsonrpc: _1.JSONRPC, id: 0, result: "foo" },
+                { jsonrpc: _1.JSONRPC, id: 1, result: "foo2" },
+            ];
+            client.receive(expectedResponses);
+        });
+        (0, mocha_1.it)("should send requests in batch", function () {
+            (0, chai_1.expect)(lastRequest).to.deep.equal(requests);
+        });
+        (0, mocha_1.it)("should return responses", function () {
+            (0, chai_1.expect)(actualResponses).to.deep.equal(expectedResponses);
+        });
+    });
+    (0, mocha_1.describe)("requesting with client params", function () {
+        var expected;
+        (0, mocha_1.beforeEach)(function () {
+            expected = { token: "baz" };
+            client.request("foo", undefined, expected);
+        });
+        (0, mocha_1.it)("should pass the client params to send function", function () {
+            (0, chai_1.expect)(lastClientParams).to.deep.equal(expected);
+        });
+    });
+    (0, mocha_1.describe)("requesting with timeout", function () {
+        var delay;
+        var fakeTimers;
+        var promise;
+        (0, mocha_1.beforeEach)(function () {
+            fakeTimers = sinon.useFakeTimers();
+            delay = 1000;
+            promise = client.timeout(delay).request("foo");
+            resolve();
+        });
+        (0, mocha_1.describe)("timing out", function () {
+            (0, mocha_1.beforeEach)(function () {
+                fakeTimers.tick(delay);
+            });
+            (0, mocha_1.it)("should reject", function () {
+                return promise.then(function () { return Promise.reject(new Error("Expected to fail")); }, function () { return undefined; });
+            });
+        });
+        (0, mocha_1.describe)("not timing out", function () {
+            var result;
+            (0, mocha_1.beforeEach)(function () {
+                result = "foo";
+                client.receive({
+                    jsonrpc: _1.JSONRPC,
+                    id: lastRequest.id,
+                    result: result,
+                });
+            });
+            (0, mocha_1.it)("should respond", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var actual;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, promise];
+                        case 1:
+                            actual = _a.sent();
+                            (0, chai_1.expect)(actual).to.equal(result);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+    (0, mocha_1.describe)("requesting advanced with timeout", function () {
+        var delay;
+        var fakeTimers;
+        var promise;
+        (0, mocha_1.beforeEach)(function () {
+            fakeTimers = sinon.useFakeTimers();
+            delay = 1000;
+            promise = client.timeout(delay).requestAdvanced({
+                jsonrpc: _1.JSONRPC,
+                id: ++id,
+                method: "foo",
+            });
+            resolve();
+        });
+        (0, mocha_1.describe)("timing out", function () {
+            (0, mocha_1.beforeEach)(function () {
+                fakeTimers.tick(delay);
+            });
+            (0, mocha_1.it)("should reject", function () {
+                return promise.then(function (result) {
+                    if (!result.error) {
+                        return Promise.reject(new Error("Expected to fail"));
+                    }
+                });
+            });
+        });
+        (0, mocha_1.describe)("not timing out", function () {
+            var result;
+            (0, mocha_1.beforeEach)(function () {
+                result = {
+                    jsonrpc: _1.JSONRPC,
+                    id: lastRequest.id,
+                    result: result,
+                };
+                client.receive(result);
+            });
+            (0, mocha_1.it)("should respond", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var actual;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, promise];
+                        case 1:
+                            actual = _a.sent();
+                            (0, chai_1.expect)(actual).to.deep.equal(result);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+    (0, mocha_1.describe)("requesting with custom timeout error response", function () {
+        var delay;
+        var fakeTimers;
+        var errorCode;
+        var errorMessage;
+        var errorData;
+        var promise;
+        (0, mocha_1.beforeEach)(function () {
+            fakeTimers = sinon.useFakeTimers();
+            delay = 1000;
+            errorCode = 123;
+            errorMessage = "Custom error message";
+            errorData = "Custom error data";
+            promise = client
+                .timeout(delay, function (id) {
+                return (0, _1.createJSONRPCErrorResponse)(id, errorCode, errorMessage, errorData);
+            })
+                .requestAdvanced({
+                jsonrpc: _1.JSONRPC,
+                id: ++id,
+                method: "foo",
+            });
+            resolve();
+        });
+        (0, mocha_1.describe)("timing out", function () {
+            (0, mocha_1.beforeEach)(function () {
+                fakeTimers.tick(delay);
+            });
+            (0, mocha_1.it)("should reject with the custom error", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var actual, expected;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, promise];
+                        case 1:
+                            actual = _a.sent();
+                            expected = {
+                                code: errorCode,
+                                message: errorMessage,
+                                data: errorData,
+                            };
+                            (0, chai_1.expect)(actual.error).to.deep.equal(expected);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+    (0, mocha_1.describe)("notifying", function () {
+        (0, mocha_1.beforeEach)(function () {
+            client.notify("foo", ["bar"], { token: "" });
+        });
+        (0, mocha_1.it)("should send the notification", function () {
+            (0, chai_1.expect)(lastRequest).to.deep.equal({
+                jsonrpc: _1.JSONRPC,
+                method: "foo",
+                params: ["bar"],
+            });
+        });
+    });
+    (0, mocha_1.describe)("notifying with client params", function () {
+        var expected;
+        (0, mocha_1.beforeEach)(function () {
+            expected = { token: "baz" };
+            client.notify("foo", undefined, expected);
+        });
+        (0, mocha_1.it)("should pass the client params to send function", function () {
+            (0, chai_1.expect)(lastClientParams).to.deep.equal(expected);
+        });
+    });
+});

node_modules/json-rpc-2.0/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./client";
+export * from "./interfaces";
+export * from "./models";
+export * from "./server";
+export * from "./server-and-client";

node_modules/json-rpc-2.0/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./server-and-client"), exports);

node_modules/json-rpc-2.0/dist/index.spec.d.ts

@@ -0,0 +1 @@
+import "mocha";

node_modules/json-rpc-2.0/dist/index.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+var chai_1 = require("chai");
+var _1 = require(".");
+describe("JSONRPCClient and JSONRPCServer", function () {
+    var server;
+    var client;
+    var id;
+    beforeEach(function () {
+        id = 0;
+        server = new _1.JSONRPCServer();
+        client = new _1.JSONRPCClient(function (request) {
+            return server.receive(request).then(function (response) {
+                if (response) {
+                    client.receive(response);
+                }
+            });
+        }, function () { return ++id; });
+    });
+    it("sending a request should resolve the result", function () {
+        beforeEach(function () {
+            server.addMethod("foo", function () { return "bar"; });
+            return client
+                .request("foo", undefined)
+                .then(function (result) { return (0, chai_1.expect)(result).to.equal("bar"); });
+        });
+    });
+    it("sending a notification should send a notification", function () {
+        var received;
+        beforeEach(function () {
+            server.addMethod("foo", function (_a) {
+                var text = _a[0];
+                return (received = text);
+            });
+            client.notify("foo", ["bar"]);
+            (0, chai_1.expect)(received).to.equal("bar");
+        });
+    });
+});

node_modules/json-rpc-2.0/dist/interfaces.d.ts

@@ -0,0 +1,15 @@
+import type { JSONRPCClient } from "./client";
+import type { JSONRPCServer } from "./server";
+import type { JSONRPCServerAndClient } from "./server-and-client";
+type MethodsType = Record<string, (params?: any) => any>;
+export interface TypedJSONRPCClient<Methods extends MethodsType, ClientParams = void> extends JSONRPCClient<ClientParams> {
+    request<Method extends Extract<keyof Methods, string>>(method: Method, ...args: Parameters<Methods[Method]>[0] extends undefined ? [void, ClientParams] : [Parameters<Methods[Method]>[0], ClientParams]): PromiseLike<ReturnType<Methods[Method]>>;
+}
+export interface TypedJSONRPCServer<Methods extends MethodsType, ServerParams = void> extends JSONRPCServer<ServerParams> {
+    addMethod<Method extends Extract<keyof Methods, string>>(name: Method, method: (params: Parameters<Methods[Method]>[0], serverParams: ServerParams) => ReturnType<Methods[Method]> | PromiseLike<ReturnType<Methods[Method]>>): void;
+}
+export interface TypedJSONRPCServerAndClient<ServerMethods extends MethodsType, ClientMethods extends MethodsType, ServerParams = void, ClientParams = void> extends JSONRPCServerAndClient<ServerParams, ClientParams> {
+    request<Method extends Extract<keyof ClientMethods, string>>(method: Method, ...args: Parameters<ClientMethods[Method]>[0] extends undefined ? [void, ClientParams] : [Parameters<ClientMethods[Method]>[0], ClientParams]): PromiseLike<ReturnType<ClientMethods[Method]>>;
+    addMethod<Method extends Extract<keyof ServerMethods, string>>(name: Method, method: (params: Parameters<ServerMethods[Method]>[0], serverParams: ServerParams) => ReturnType<ServerMethods[Method]> | PromiseLike<ReturnType<ServerMethods[Method]>>): void;
+}
+export {};

node_modules/json-rpc-2.0/dist/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/json-rpc-2.0/dist/interfaces.spec.d.ts

@@ -0,0 +1 @@
+import "mocha";

node_modules/json-rpc-2.0/dist/interfaces.spec.js

@@ -0,0 +1,201 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+var chai_1 = require("chai");
+var client_1 = require("./client");
+var server_1 = require("./server");
+var server_and_client_1 = require("./server-and-client");
+describe("interfaces", function () {
+    describe("independent server and client", function () {
+        var client;
+        var server;
+        beforeEach(function () {
+            client = new client_1.JSONRPCClient(function (request) { return __awaiter(void 0, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, server.receive(request)];
+                        case 1:
+                            response = _a.sent();
+                            if (response) {
+                                client.receive(response);
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            server = new server_1.JSONRPCServer();
+        });
+        describe("calling method with no args no return", function () {
+            var noArgsNoReturnCalled;
+            beforeEach(function () {
+                noArgsNoReturnCalled = false;
+                server.addMethod("noArgsNoReturn", function () {
+                    noArgsNoReturnCalled = true;
+                });
+                return client.request("noArgsNoReturn");
+            });
+            it("should call the method", function () {
+                (0, chai_1.expect)(noArgsNoReturnCalled).to.be.true;
+            });
+        });
+        describe("calling method with no args", function () {
+            var expected;
+            var actual;
+            beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            expected = "return value";
+                            server.addMethod("noArgs", function () {
+                                return expected;
+                            });
+                            return [4 /*yield*/, client.request("noArgs")];
+                        case 1:
+                            actual = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("should call the method", function () {
+                (0, chai_1.expect)(actual).to.equal(expected);
+            });
+        });
+        describe("calling method with object args", function () {
+            var actual;
+            beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            server.addMethod("objectArgs", function (_a) {
+                                var foo = _a.foo, bar = _a.bar;
+                                return "".concat(foo, ".").concat(bar);
+                            });
+                            return [4 /*yield*/, client.request("objectArgs", {
+                                    foo: "string value",
+                                    bar: 123,
+                                })];
+                        case 1:
+                            actual = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("should call the method", function () {
+                (0, chai_1.expect)(actual).to.equal("string value.123");
+            });
+        });
+        describe("calling method with array args", function () {
+            var actual;
+            beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            server.addMethod("arrayArgs", function (_a) {
+                                var foo = _a[0], bar = _a[1];
+                                return "".concat(foo, ".").concat(bar);
+                            });
+                            return [4 /*yield*/, client.request("arrayArgs", ["string value", 123])];
+                        case 1:
+                            actual = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("should call the method", function () {
+                (0, chai_1.expect)(actual).to.equal("string value.123");
+            });
+        });
+    });
+    describe("server and client", function () {
+        var serverAndClientA;
+        var serverAndClientB;
+        beforeEach(function () {
+            serverAndClientA = new server_and_client_1.JSONRPCServerAndClient(new server_1.JSONRPCServer(), new client_1.JSONRPCClient(function (request) {
+                return serverAndClientB.receiveAndSend(request);
+            }));
+            serverAndClientB = new server_and_client_1.JSONRPCServerAndClient(new server_1.JSONRPCServer(), new client_1.JSONRPCClient(function (request) {
+                return serverAndClientA.receiveAndSend(request);
+            }));
+            serverAndClientA.addMethod("echo", function (_a) {
+                var message = _a.message;
+                return message;
+            });
+            serverAndClientB.addMethod("sum", function (_a) {
+                var x = _a.x, y = _a.y;
+                return x + y;
+            });
+        });
+        describe("calling method from server A to B", function () {
+            var actual;
+            beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, serverAndClientA.request("sum", { x: 1, y: 2 })];
+                        case 1:
+                            actual = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("should call the method", function () {
+                (0, chai_1.expect)(actual).to.equal(3);
+            });
+        });
+        describe("calling method from server B to A", function () {
+            var expected;
+            var actual;
+            beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            expected = "hello";
+                            return [4 /*yield*/, serverAndClientB.request("echo", { message: expected })];
+                        case 1:
+                            actual = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("should call the method", function () {
+                (0, chai_1.expect)(actual).to.equal(expected);
+            });
+        });
+    });
+});

node_modules/json-rpc-2.0/dist/internal.d.ts

@@ -0,0 +1 @@
+export declare const DefaultErrorCode = 0;

node_modules/json-rpc-2.0/dist/internal.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultErrorCode = void 0;
+exports.DefaultErrorCode = 0;

node_modules/json-rpc-2.0/dist/models.d.ts

@@ -0,0 +1,51 @@
+export type JSONRPC = "2.0";
+export declare const JSONRPC: JSONRPC;
+export type JSONRPCID = string | number | null;
+export type JSONRPCParams = any;
+export declare const isJSONRPCID: (id: any) => id is JSONRPCID;
+export interface JSONRPCRequest {
+    jsonrpc: JSONRPC;
+    method: string;
+    params?: JSONRPCParams;
+    id?: JSONRPCID;
+}
+export type JSONRPCResponse = JSONRPCSuccessResponse | JSONRPCErrorResponse;
+export interface JSONRPCSuccessResponse {
+    jsonrpc: JSONRPC;
+    id: JSONRPCID;
+    result: any;
+    error?: undefined;
+}
+export interface JSONRPCErrorResponse {
+    jsonrpc: JSONRPC;
+    id: JSONRPCID;
+    result?: undefined;
+    error: JSONRPCError;
+}
+export declare const isJSONRPCRequest: (payload: any) => payload is JSONRPCRequest;
+export declare const isJSONRPCRequests: (payload: any) => payload is JSONRPCRequest[];
+export declare const isJSONRPCResponse: (payload: any) => payload is JSONRPCResponse;
+export declare const isJSONRPCResponses: (payload: any) => payload is JSONRPCResponse[];
+export interface JSONRPCError {
+    code: number;
+    message: string;
+    data?: any;
+}
+export declare class JSONRPCErrorException extends Error implements JSONRPCError {
+    code: number;
+    data?: any;
+    constructor(message: string, code: number, data?: any);
+    toObject(): JSONRPCError;
+}
+export declare enum JSONRPCErrorCode {
+    ParseError = -32700,
+    InvalidRequest = -32600,
+    MethodNotFound = -32601,
+    InvalidParams = -32602,
+    InternalError = -32603
+}
+export declare const createJSONRPCErrorResponse: (id: JSONRPCID, code: number, message: string, data?: any) => JSONRPCErrorResponse;
+export declare const createJSONRPCSuccessResponse: (id: JSONRPCID, result?: any) => JSONRPCSuccessResponse;
+export declare const createJSONRPCRequest: (id: JSONRPCID, method: string, params?: JSONRPCParams) => JSONRPCRequest;
+export declare const createJSONRPCNotification: (method: string, params?: JSONRPCParams) => JSONRPCRequest;
+export type ErrorListener = (message: string, data: unknown) => void;

node_modules/json-rpc-2.0/dist/models.js

@@ -0,0 +1,109 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJSONRPCNotification = exports.createJSONRPCRequest = exports.createJSONRPCSuccessResponse = exports.createJSONRPCErrorResponse = exports.JSONRPCErrorCode = exports.JSONRPCErrorException = exports.isJSONRPCResponses = exports.isJSONRPCResponse = exports.isJSONRPCRequests = exports.isJSONRPCRequest = exports.isJSONRPCID = exports.JSONRPC = void 0;
+exports.JSONRPC = "2.0";
+var isJSONRPCID = function (id) {
+    return typeof id === "string" || typeof id === "number" || id === null;
+};
+exports.isJSONRPCID = isJSONRPCID;
+var isJSONRPCRequest = function (payload) {
+    return (payload.jsonrpc === exports.JSONRPC &&
+        payload.method !== undefined &&
+        payload.result === undefined &&
+        payload.error === undefined);
+};
+exports.isJSONRPCRequest = isJSONRPCRequest;
+var isJSONRPCRequests = function (payload) {
+    return Array.isArray(payload) && payload.every(exports.isJSONRPCRequest);
+};
+exports.isJSONRPCRequests = isJSONRPCRequests;
+var isJSONRPCResponse = function (payload) {
+    return (payload.jsonrpc === exports.JSONRPC &&
+        payload.id !== undefined &&
+        (payload.result !== undefined || payload.error !== undefined));
+};
+exports.isJSONRPCResponse = isJSONRPCResponse;
+var isJSONRPCResponses = function (payload) {
+    return Array.isArray(payload) && payload.every(exports.isJSONRPCResponse);
+};
+exports.isJSONRPCResponses = isJSONRPCResponses;
+var createJSONRPCError = function (code, message, data) {
+    var error = { code: code, message: message };
+    if (data != null) {
+        error.data = data;
+    }
+    return error;
+};
+var JSONRPCErrorException = /** @class */ (function (_super) {
+    __extends(JSONRPCErrorException, _super);
+    function JSONRPCErrorException(message, code, data) {
+        var _this = _super.call(this, message) || this;
+        // Manually set the prototype to fix TypeScript issue:
+        // https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        Object.setPrototypeOf(_this, JSONRPCErrorException.prototype);
+        _this.code = code;
+        _this.data = data;
+        return _this;
+    }
+    JSONRPCErrorException.prototype.toObject = function () {
+        return createJSONRPCError(this.code, this.message, this.data);
+    };
+    return JSONRPCErrorException;
+}(Error));
+exports.JSONRPCErrorException = JSONRPCErrorException;
+var JSONRPCErrorCode;
+(function (JSONRPCErrorCode) {
+    JSONRPCErrorCode[JSONRPCErrorCode["ParseError"] = -32700] = "ParseError";
+    JSONRPCErrorCode[JSONRPCErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+    JSONRPCErrorCode[JSONRPCErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+    JSONRPCErrorCode[JSONRPCErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+    JSONRPCErrorCode[JSONRPCErrorCode["InternalError"] = -32603] = "InternalError";
+})(JSONRPCErrorCode = exports.JSONRPCErrorCode || (exports.JSONRPCErrorCode = {}));
+var createJSONRPCErrorResponse = function (id, code, message, data) {
+    return {
+        jsonrpc: exports.JSONRPC,
+        id: id,
+        error: createJSONRPCError(code, message, data),
+    };
+};
+exports.createJSONRPCErrorResponse = createJSONRPCErrorResponse;
+var createJSONRPCSuccessResponse = function (id, result) {
+    return {
+        jsonrpc: exports.JSONRPC,
+        id: id,
+        result: result !== null && result !== void 0 ? result : null,
+    };
+};
+exports.createJSONRPCSuccessResponse = createJSONRPCSuccessResponse;
+var createJSONRPCRequest = function (id, method, params) {
+    return {
+        jsonrpc: exports.JSONRPC,
+        id: id,
+        method: method,
+        params: params,
+    };
+};
+exports.createJSONRPCRequest = createJSONRPCRequest;
+var createJSONRPCNotification = function (method, params) {
+    return {
+        jsonrpc: exports.JSONRPC,
+        method: method,
+        params: params,
+    };
+};
+exports.createJSONRPCNotification = createJSONRPCNotification;

node_modules/json-rpc-2.0/dist/server-and-client.d.ts

@@ -0,0 +1,24 @@
+import { JSONRPCMethod, JSONRPCServer, JSONRPCServerMiddleware, SimpleJSONRPCMethod } from "./server";
+import { JSONRPCClient, JSONRPCRequester } from "./client";
+import { ErrorListener, JSONRPCParams, JSONRPCRequest, JSONRPCResponse } from "./models";
+export interface JSONRPCServerAndClientOptions {
+    errorListener?: ErrorListener;
+}
+export declare class JSONRPCServerAndClient<ServerParams = void, ClientParams = void> {
+    server: JSONRPCServer<ServerParams>;
+    client: JSONRPCClient<ClientParams>;
+    private readonly errorListener;
+    constructor(server: JSONRPCServer<ServerParams>, client: JSONRPCClient<ClientParams>, options?: JSONRPCServerAndClientOptions);
+    applyServerMiddleware(...middlewares: JSONRPCServerMiddleware<ServerParams>[]): void;
+    hasMethod(name: string): boolean;
+    addMethod(name: string, method: SimpleJSONRPCMethod<ServerParams>): void;
+    addMethodAdvanced(name: string, method: JSONRPCMethod<ServerParams>): void;
+    removeMethod(name: string): void;
+    timeout(delay: number): JSONRPCRequester<ClientParams>;
+    request(method: string, params: JSONRPCParams, clientParams: ClientParams): PromiseLike<any>;
+    requestAdvanced(jsonRPCRequest: JSONRPCRequest, clientParams: ClientParams): PromiseLike<JSONRPCResponse>;
+    requestAdvanced(jsonRPCRequest: JSONRPCRequest[], clientParams: ClientParams): PromiseLike<JSONRPCResponse[]>;
+    notify(method: string, params: JSONRPCParams, clientParams: ClientParams): void;
+    rejectAllPendingRequests(message: string): void;
+    receiveAndSend(payload: any, serverParams: ServerParams, clientParams: ClientParams): Promise<void>;
+}

node_modules/json-rpc-2.0/dist/server-and-client.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONRPCServerAndClient = void 0;
+var models_1 = require("./models");
+var JSONRPCServerAndClient = /** @class */ (function () {
+    function JSONRPCServerAndClient(server, client, options) {
+        if (options === void 0) { options = {}; }
+        var _a;
+        this.server = server;
+        this.client = client;
+        this.errorListener = (_a = options.errorListener) !== null && _a !== void 0 ? _a : console.warn;
+    }
+    JSONRPCServerAndClient.prototype.applyServerMiddleware = function () {
+        var _a;
+        var middlewares = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            middlewares[_i] = arguments[_i];
+        }
+        (_a = this.server).applyMiddleware.apply(_a, middlewares);
+    };
+    JSONRPCServerAndClient.prototype.hasMethod = function (name) {
+        return this.server.hasMethod(name);
+    };
+    JSONRPCServerAndClient.prototype.addMethod = function (name, method) {
+        this.server.addMethod(name, method);
+    };
+    JSONRPCServerAndClient.prototype.addMethodAdvanced = function (name, method) {
+        this.server.addMethodAdvanced(name, method);
+    };
+    JSONRPCServerAndClient.prototype.removeMethod = function (name) {
+        this.server.removeMethod(name);
+    };
+    JSONRPCServerAndClient.prototype.timeout = function (delay) {
+        return this.client.timeout(delay);
+    };
+    JSONRPCServerAndClient.prototype.request = function (method, params, clientParams) {
+        return this.client.request(method, params, clientParams);
+    };
+    JSONRPCServerAndClient.prototype.requestAdvanced = function (jsonRPCRequest, clientParams) {
+        return this.client.requestAdvanced(jsonRPCRequest, clientParams);
+    };
+    JSONRPCServerAndClient.prototype.notify = function (method, params, clientParams) {
+        this.client.notify(method, params, clientParams);
+    };
+    JSONRPCServerAndClient.prototype.rejectAllPendingRequests = function (message) {
+        this.client.rejectAllPendingRequests(message);
+    };
+    JSONRPCServerAndClient.prototype.receiveAndSend = function (payload, serverParams, clientParams) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, message;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!((0, models_1.isJSONRPCResponse)(payload) || (0, models_1.isJSONRPCResponses)(payload))) return [3 /*break*/, 1];
+                        this.client.receive(payload);
+                        return [3 /*break*/, 4];
+                    case 1:
+                        if (!((0, models_1.isJSONRPCRequest)(payload) || (0, models_1.isJSONRPCRequests)(payload))) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.server.receive(payload, serverParams)];
+                    case 2:
+                        response = _a.sent();
+                        if (response) {
+                            return [2 /*return*/, this.client.send(response, clientParams)];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        message = "Received an invalid JSON-RPC message";
+                        this.errorListener(message, payload);
+                        return [2 /*return*/, Promise.reject(new Error(message))];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return JSONRPCServerAndClient;
+}());
+exports.JSONRPCServerAndClient = JSONRPCServerAndClient;

node_modules/json-rpc-2.0/dist/server-and-client.spec.d.ts

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

node_modules/json-rpc-2.0/dist/server-and-client.spec.js

@@ -0,0 +1,244 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mocha_1 = require("mocha");
+var chai_1 = require("chai");
+var sinon = require("sinon");
+var _1 = require(".");
+var client_1 = require("./client");
+(0, mocha_1.describe)("JSONRPCServerAndClient", function () {
+    var serverAndClient1;
+    var serverAndClient2;
+    (0, mocha_1.beforeEach)(function () {
+        serverAndClient1 = new _1.JSONRPCServerAndClient(new _1.JSONRPCServer(), new client_1.JSONRPCClient(function (payload) {
+            return serverAndClient2.receiveAndSend(payload, undefined);
+        }));
+        serverAndClient2 = new _1.JSONRPCServerAndClient(new _1.JSONRPCServer(), new client_1.JSONRPCClient(function (payload, params) {
+            return serverAndClient1.receiveAndSend(payload, params);
+        }));
+        serverAndClient1.addMethod("echo1", function (_a) {
+            var message = _a.message;
+            return message;
+        });
+        serverAndClient1.addMethodAdvanced("echo1-2", function (jsonRPCRequest, params) { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, ({
+                        jsonrpc: _1.JSONRPC,
+                        id: jsonRPCRequest.id,
+                        result: "".concat(params === null || params === void 0 ? void 0 : params.userID, " said ").concat(jsonRPCRequest.params.message),
+                    })];
+            });
+        }); });
+        serverAndClient2.addMethod("echo2", function (_a) {
+            var message = _a.message;
+            return message;
+        });
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    (0, mocha_1.describe)("requesting from server 1", function () {
+        var result;
+        (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, serverAndClient1.request("echo2", { message: "foo" })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, mocha_1.it)("should request to server 2", function () {
+            (0, chai_1.expect)(result).to.equal("foo");
+        });
+        (0, mocha_1.describe)("removing the method", function () {
+            (0, mocha_1.beforeEach)(function () {
+                serverAndClient2.removeMethod("echo2");
+            });
+            (0, mocha_1.describe)("requesting from server 1", function () {
+                var response;
+                (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, serverAndClient1.requestAdvanced({
+                                    jsonrpc: _1.JSONRPC,
+                                    id: 0,
+                                    method: "echo2",
+                                    params: { message: "foo" },
+                                })];
+                            case 1:
+                                response = _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                (0, mocha_1.it)("should return not found", function () {
+                    var _a;
+                    (0, chai_1.expect)((_a = response.error) === null || _a === void 0 ? void 0 : _a.code).to.equal(_1.JSONRPCErrorCode.MethodNotFound);
+                });
+            });
+        });
+    });
+    (0, mocha_1.describe)("requesting from server 2", function () {
+        var result;
+        (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, serverAndClient2.request("echo1", { message: "bar" })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, mocha_1.it)("should request to server 1", function () {
+            (0, chai_1.expect)(result).to.equal("bar");
+        });
+    });
+    (0, mocha_1.describe)("requesting from server 1 using advanced method", function () {
+        var response;
+        (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+            var request;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        request = {
+                            jsonrpc: _1.JSONRPC,
+                            id: 0,
+                            method: "echo1-2",
+                            params: { message: "test" },
+                        };
+                        return [4 /*yield*/, serverAndClient2.requestAdvanced(request, {
+                                userID: "baz",
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, mocha_1.it)("should request to server 1", function () {
+            (0, chai_1.expect)(response.result).to.equal("baz said test");
+        });
+    });
+    (0, mocha_1.describe)("requesting in batch", function () {
+        var responses;
+        (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+            var requests;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        requests = [
+                            { jsonrpc: _1.JSONRPC, id: 0, method: "echo2", params: { message: "1" } },
+                            { jsonrpc: _1.JSONRPC, id: 1, method: "echo2", params: { message: "2" } },
+                        ];
+                        return [4 /*yield*/, serverAndClient1.requestAdvanced(requests)];
+                    case 1:
+                        responses = _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, mocha_1.it)("should return responses", function () {
+            (0, chai_1.expect)(responses).to.deep.equal([
+                { jsonrpc: _1.JSONRPC, id: 0, result: "1" },
+                { jsonrpc: _1.JSONRPC, id: 1, result: "2" },
+            ]);
+        });
+    });
+    (0, mocha_1.describe)("receiving invalid JSON-RPC message", function () {
+        var promise;
+        (0, mocha_1.beforeEach)(function () {
+            promise = serverAndClient1.receiveAndSend({});
+        });
+        (0, mocha_1.it)("should fail", function () {
+            return promise.then(function () { return Promise.reject(new Error("Expected to fail")); }, function () { return undefined; });
+        });
+    });
+    (0, mocha_1.describe)("having a pending request", function () {
+        var promise;
+        var resolve;
+        (0, mocha_1.beforeEach)(function () {
+            serverAndClient2.addMethod("hang", function () {
+                return new Promise(function (givenResolve) { return (resolve = givenResolve); });
+            });
+            promise = serverAndClient1.request("hang", undefined);
+        });
+        (0, mocha_1.describe)("rejecting all pending requests", function () {
+            var message;
+            (0, mocha_1.beforeEach)(function () {
+                message = "Connection is closed.";
+                serverAndClient1.rejectAllPendingRequests(message);
+                resolve();
+            });
+            (0, mocha_1.it)("should reject the pending request", function () {
+                return promise.then(function () { return Promise.reject(new Error("Expected to fail")); }, function (error) { return (0, chai_1.expect)(error.message).to.equal(message); });
+            });
+        });
+    });
+    (0, mocha_1.describe)("requesting with timeout", function () {
+        var fakeTimers;
+        var delay;
+        var resolve;
+        var promise;
+        (0, mocha_1.beforeEach)(function () {
+            fakeTimers = sinon.useFakeTimers();
+            delay = 100;
+            serverAndClient2.addMethod("timeout", function () { return new Promise(function (givenResolve) { return (resolve = givenResolve); }); });
+            promise = serverAndClient1.timeout(delay).request("timeout");
+        });
+        (0, mocha_1.describe)("timing out", function () {
+            (0, mocha_1.beforeEach)(function () {
+                fakeTimers.tick(delay);
+                resolve();
+            });
+            (0, mocha_1.it)("should reject", function () {
+                return promise.then(function () { return Promise.reject(new Error("Expected to fail")); }, function () { return undefined; });
+            });
+        });
+        (0, mocha_1.describe)("not timing out", function () {
+            (0, mocha_1.beforeEach)(function () {
+                resolve();
+            });
+            (0, mocha_1.it)("should succeed", function () {
+                return promise;
+            });
+        });
+    });
+});

node_modules/json-rpc-2.0/dist/server.d.ts

@@ -0,0 +1,32 @@
+import { JSONRPCRequest, JSONRPCResponse, JSONRPCParams, JSONRPCID, JSONRPCErrorResponse, ErrorListener } from "./models";
+export type SimpleJSONRPCMethod<ServerParams = void> = (params: JSONRPCParams, serverParams: ServerParams) => any;
+export type JSONRPCMethod<ServerParams = void> = (request: JSONRPCRequest, serverParams: ServerParams) => JSONRPCResponsePromise;
+export type JSONRPCResponsePromise = PromiseLike<JSONRPCResponse | null>;
+export type JSONRPCServerMiddlewareNext<ServerParams> = (request: JSONRPCRequest, serverParams: ServerParams) => JSONRPCResponsePromise;
+export type JSONRPCServerMiddleware<ServerParams> = (next: JSONRPCServerMiddlewareNext<ServerParams>, request: JSONRPCRequest, serverParams: ServerParams) => JSONRPCResponsePromise;
+export interface JSONRPCServerOptions {
+    errorListener?: ErrorListener;
+}
+export declare class JSONRPCServer<ServerParams = void> {
+    private nameToMethodDictionary;
+    private middleware;
+    private readonly errorListener;
+    mapErrorToJSONRPCErrorResponse: (id: JSONRPCID, error: any) => JSONRPCErrorResponse;
+    constructor(options?: JSONRPCServerOptions);
+    hasMethod(name: string): boolean;
+    addMethod(name: string, method: SimpleJSONRPCMethod<ServerParams>): void;
+    removeMethod(name: string): void;
+    private toJSONRPCMethod;
+    addMethodAdvanced(name: string, method: JSONRPCMethod<ServerParams>): void;
+    receiveJSON(json: string, serverParams?: ServerParams): PromiseLike<JSONRPCResponse | JSONRPCResponse[] | null>;
+    private tryParseRequestJSON;
+    receive(request: JSONRPCRequest, serverParams?: ServerParams): PromiseLike<JSONRPCResponse | null>;
+    receive(request: JSONRPCRequest | JSONRPCRequest[], serverParams?: ServerParams): PromiseLike<JSONRPCResponse | JSONRPCResponse[] | null>;
+    private receiveMultiple;
+    private receiveSingle;
+    applyMiddleware(...middlewares: JSONRPCServerMiddleware<ServerParams>[]): void;
+    private combineMiddlewares;
+    private middlewareReducer;
+    private callMethod;
+    private mapErrorToJSONRPCErrorResponseIfNecessary;
+}

node_modules/json-rpc-2.0/dist/server.js

@@ -0,0 +1,259 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONRPCServer = void 0;
+var models_1 = require("./models");
+var internal_1 = require("./internal");
+var createParseErrorResponse = function () {
+    return (0, models_1.createJSONRPCErrorResponse)(null, models_1.JSONRPCErrorCode.ParseError, "Parse error");
+};
+var createInvalidRequestResponse = function (request) {
+    return (0, models_1.createJSONRPCErrorResponse)((0, models_1.isJSONRPCID)(request.id) ? request.id : null, models_1.JSONRPCErrorCode.InvalidRequest, "Invalid Request");
+};
+var createMethodNotFoundResponse = function (id) {
+    return (0, models_1.createJSONRPCErrorResponse)(id, models_1.JSONRPCErrorCode.MethodNotFound, "Method not found");
+};
+var JSONRPCServer = /** @class */ (function () {
+    function JSONRPCServer(options) {
+        if (options === void 0) { options = {}; }
+        var _a;
+        this.mapErrorToJSONRPCErrorResponse = defaultMapErrorToJSONRPCErrorResponse;
+        this.nameToMethodDictionary = {};
+        this.middleware = null;
+        this.errorListener = (_a = options.errorListener) !== null && _a !== void 0 ? _a : console.warn;
+    }
+    JSONRPCServer.prototype.hasMethod = function (name) {
+        return !!this.nameToMethodDictionary[name];
+    };
+    JSONRPCServer.prototype.addMethod = function (name, method) {
+        this.addMethodAdvanced(name, this.toJSONRPCMethod(method));
+    };
+    JSONRPCServer.prototype.removeMethod = function (name) {
+        delete this.nameToMethodDictionary[name];
+    };
+    JSONRPCServer.prototype.toJSONRPCMethod = function (method) {
+        return function (request, serverParams) {
+            var response = method(request.params, serverParams);
+            return Promise.resolve(response).then(function (result) {
+                return mapResultToJSONRPCResponse(request.id, result);
+            });
+        };
+    };
+    JSONRPCServer.prototype.addMethodAdvanced = function (name, method) {
+        var _a;
+        this.nameToMethodDictionary = __assign(__assign({}, this.nameToMethodDictionary), (_a = {}, _a[name] = method, _a));
+    };
+    JSONRPCServer.prototype.receiveJSON = function (json, serverParams) {
+        var request = this.tryParseRequestJSON(json);
+        if (request) {
+            return this.receive(request, serverParams);
+        }
+        else {
+            return Promise.resolve(createParseErrorResponse());
+        }
+    };
+    JSONRPCServer.prototype.tryParseRequestJSON = function (json) {
+        try {
+            return JSON.parse(json);
+        }
+        catch (_a) {
+            return null;
+        }
+    };
+    JSONRPCServer.prototype.receive = function (request, serverParams) {
+        if (Array.isArray(request)) {
+            return this.receiveMultiple(request, serverParams);
+        }
+        else {
+            return this.receiveSingle(request, serverParams);
+        }
+    };
+    JSONRPCServer.prototype.receiveMultiple = function (requests, serverParams) {
+        return __awaiter(this, void 0, void 0, function () {
+            var responses;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(requests.map(function (request) { return _this.receiveSingle(request, serverParams); }))];
+                    case 1:
+                        responses = (_a.sent()).filter(isNonNull);
+                        if (responses.length === 1) {
+                            return [2 /*return*/, responses[0]];
+                        }
+                        else if (responses.length) {
+                            return [2 /*return*/, responses];
+                        }
+                        else {
+                            return [2 /*return*/, null];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    JSONRPCServer.prototype.receiveSingle = function (request, serverParams) {
+        return __awaiter(this, void 0, void 0, function () {
+            var method, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        method = this.nameToMethodDictionary[request.method];
+                        if (!!(0, models_1.isJSONRPCRequest)(request)) return [3 /*break*/, 1];
+                        return [2 /*return*/, createInvalidRequestResponse(request)];
+                    case 1: return [4 /*yield*/, this.callMethod(method, request, serverParams)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, mapResponse(request, response)];
+                }
+            });
+        });
+    };
+    JSONRPCServer.prototype.applyMiddleware = function () {
+        var middlewares = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            middlewares[_i] = arguments[_i];
+        }
+        if (this.middleware) {
+            this.middleware = this.combineMiddlewares(__spreadArray([
+                this.middleware
+            ], middlewares, true));
+        }
+        else {
+            this.middleware = this.combineMiddlewares(middlewares);
+        }
+    };
+    JSONRPCServer.prototype.combineMiddlewares = function (middlewares) {
+        if (!middlewares.length) {
+            return null;
+        }
+        else {
+            return middlewares.reduce(this.middlewareReducer);
+        }
+    };
+    JSONRPCServer.prototype.middlewareReducer = function (prevMiddleware, nextMiddleware) {
+        return function (next, request, serverParams) {
+            return prevMiddleware(function (request, serverParams) { return nextMiddleware(next, request, serverParams); }, request, serverParams);
+        };
+    };
+    JSONRPCServer.prototype.callMethod = function (method, request, serverParams) {
+        var _this = this;
+        var callMethod = function (request, serverParams) {
+            if (method) {
+                return method(request, serverParams);
+            }
+            else if (request.id !== undefined) {
+                return Promise.resolve(createMethodNotFoundResponse(request.id));
+            }
+            else {
+                return Promise.resolve(null);
+            }
+        };
+        var onError = function (error) {
+            _this.errorListener("An unexpected error occurred while executing \"".concat(request.method, "\" JSON-RPC method:"), error);
+            return Promise.resolve(_this.mapErrorToJSONRPCErrorResponseIfNecessary(request.id, error));
+        };
+        try {
+            return (this.middleware || noopMiddleware)(callMethod, request, serverParams).then(undefined, onError);
+        }
+        catch (error) {
+            return onError(error);
+        }
+    };
+    JSONRPCServer.prototype.mapErrorToJSONRPCErrorResponseIfNecessary = function (id, error) {
+        if (id !== undefined) {
+            return this.mapErrorToJSONRPCErrorResponse(id, error);
+        }
+        else {
+            return null;
+        }
+    };
+    return JSONRPCServer;
+}());
+exports.JSONRPCServer = JSONRPCServer;
+var isNonNull = function (value) { return value !== null; };
+var noopMiddleware = function (next, request, serverParams) { return next(request, serverParams); };
+var mapResultToJSONRPCResponse = function (id, result) {
+    if (id !== undefined) {
+        return (0, models_1.createJSONRPCSuccessResponse)(id, result);
+    }
+    else {
+        return null;
+    }
+};
+var defaultMapErrorToJSONRPCErrorResponse = function (id, error) {
+    var _a;
+    var message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : "An unexpected error occurred";
+    var code = internal_1.DefaultErrorCode;
+    var data;
+    if (error instanceof models_1.JSONRPCErrorException) {
+        code = error.code;
+        data = error.data;
+    }
+    return (0, models_1.createJSONRPCErrorResponse)(id, code, message, data);
+};
+var mapResponse = function (request, response) {
+    if (response) {
+        return response;
+    }
+    else if (request.id !== undefined) {
+        return (0, models_1.createJSONRPCErrorResponse)(request.id, models_1.JSONRPCErrorCode.InternalError, "Internal error");
+    }
+    else {
+        return null;
+    }
+};

node_modules/json-rpc-2.0/dist/server.spec.d.ts

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

node_modules/json-rpc-2.0/dist/server.spec.js

@@ -0,0 +1,746 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mocha_1 = require("mocha");
+var chai_1 = require("chai");
+var _1 = require(".");
+(0, mocha_1.describe)("JSONRPCServer", function () {
+    var server;
+    var response;
+    (0, mocha_1.beforeEach)(function () {
+        response = null;
+        server = new _1.JSONRPCServer();
+    });
+    var waitUntil = function (predicate) {
+        return Promise.resolve().then(function () {
+            if (!predicate()) {
+                return waitUntil(predicate);
+            }
+        });
+    };
+    (0, mocha_1.describe)("having an echo method", function () {
+        (0, mocha_1.beforeEach)(function () {
+            var echoMethod = function (_a, serverParams) {
+                var text = _a.text;
+                if (serverParams) {
+                    return "".concat(serverParams.userID, " said ").concat(text);
+                }
+                else {
+                    return text;
+                }
+            };
+            server.addMethod("echo", echoMethod);
+        });
+        (0, mocha_1.describe)("receiving a request to the method", function () {
+            (0, mocha_1.beforeEach)(function () {
+                return server
+                    .receive({
+                    jsonrpc: _1.JSONRPC,
+                    id: 0,
+                    method: "echo",
+                    params: { text: "foo" },
+                })
+                    .then(function (givenResponse) { return (response = givenResponse); });
+            });
+            (0, mocha_1.it)("should echo the text", function () {
+                (0, chai_1.expect)(response).to.deep.equal({
+                    jsonrpc: _1.JSONRPC,
+                    id: 0,
+                    result: "foo",
+                });
+            });
+        });
+        (0, mocha_1.describe)("receiving a request to the method with user ID", function () {
+            (0, mocha_1.beforeEach)(function () {
+                return server
+                    .receiveJSON(JSON.stringify({
+                    jsonrpc: _1.JSONRPC,
+                    id: 0,
+                    method: "echo",
+                    params: { text: "foo" },
+                }), { userID: "bar" })
+                    .then(function (givenResponse) { return (response = givenResponse); });
+            });
+            (0, mocha_1.it)("should echo the text with the user ID", function () {
+                (0, chai_1.expect)(response).to.deep.equal({
+                    jsonrpc: _1.JSONRPC,
+                    id: 0,
+                    result: "bar said foo",
+                });
+            });
+        });
+        (0, mocha_1.describe)("removing the echo method", function () {
+            (0, mocha_1.beforeEach)(function () {
+                server.removeMethod("echo");
+            });
+            (0, mocha_1.describe)("receiving a request to the method", function () {
+                (0, mocha_1.beforeEach)(function () {
+                    return server
+                        .receive({
+                        jsonrpc: _1.JSONRPC,
+                        id: 0,
+                        method: "echo",
+                        params: { text: "foo" },
+                    })
+                        .then(function (givenResponse) { return (response = givenResponse); });
+                });
+                (0, mocha_1.it)("should respond not found", function () {
+                    var _a;
+                    (0, chai_1.expect)((_a = response === null || response === void 0 ? void 0 : response.error) === null || _a === void 0 ? void 0 : _a.code).to.equal(_1.JSONRPCErrorCode.MethodNotFound);
+                });
+            });
+        });
+    });
+    (0, mocha_1.describe)("responding undefined", function () {
+        (0, mocha_1.beforeEach)(function () {
+            server.addMethod("ack", function () { return undefined; });
+            return server
+                .receive({ jsonrpc: _1.JSONRPC, id: 0, method: "ack" })
+                .then(function (givenResponse) { return (response = givenResponse); });
+        });
+        (0, mocha_1.it)("should response with null result", function () {
+            (0, chai_1.expect)(response).to.deep.equal({
+                jsonrpc: _1.JSONRPC,
+                id: 0,
+                result: null,
+            });
+        });
+    });
+    (0, mocha_1.describe)("throwing", function () {
+        (0, mocha_1.beforeEach)(function () {
+            server.addMethod("throw", function () {
+                throw new Error("Test throwing");
+            });
+            return server
+                .receive({ jsonrpc: _1.JSONRPC, id: 0, method: "throw" })
+                .then(function (givenResponse) { return (response = givenResponse); });
+        });
+        (0, mocha_1.it)("should respond error", function () {
+            (0, chai_1.expect)(response).to.deep.equal({
+                jsonrpc: _1.JSONRPC,
+                id: 0,
+                error: {
+                    code: 0,
+                    message: "Test throwing",
+                },
+            });
+        });
+    });
+    (0, mocha_1.describe)("throwing JSONRPCErrorException", function () {
+        var expected;
+        (0, mocha_1.beforeEach)(function () {
+            expected = {
+                message: "thrown",
+                code: 1234,
+                data: {
+                    foo: "bar",
+                },
+            };
+            server.addMethod("throw", function () {
+                throw new _1.JSONRPCErrorException(expected.message, expected.code, expected.data);
+            });
+            return server
+                .receive({ jsonrpc: _1.JSONRPC, id: 0, method: "throw" })
+                .then(function (givenResponse) { return (response = givenResponse); });
+        });
+        (0, mocha_1.it)("should respond error with custom code and data", function () {
+            (0, chai_1.expect)(response.error).to.deep.equal(expected);
+        });
+    });
+    (0, mocha_1.describe)("rejecting", function () {
+        (0, mocha_1.beforeEach)(function () {
+            server.addMethodAdvanced("reject", function () {
+                return Promise.reject(new Error("Test rejecting"));
+            });
+            return server
+                .receive({ jsonrpc: _1.JSONRPC, id: 0, method: "reject" })
+                .then(function (givenResponse) { return (response = givenResponse); });
+        });
+        (0, mocha_1.it)("should respond error", function () {
+            (0, chai_1.expect)(response).to.deep.equal({
+                jsonrpc: _1.JSONRPC,
+                id: 0,
+                error: {
+                    code: 0,
+                    message: "Test rejecting",
+                },
+            });
+        });
+    });
+    (0, mocha_1.describe)("responding to a notification", function () {
+        (0, mocha_1.beforeEach)(function () {
+            server.addMethod("foo", function () { return "foo"; });
+            return server
+                .receive({ jsonrpc: _1.JSONRPC, method: "foo" })
+                .then(function (givenResponse) { return (response = givenResponse); });
+        });
+        (0, mocha_1.it)("should not respond", function () {
+            (0, chai_1.expect)(response).to.be.null;
+        });
+    });
+    (0, mocha_1.describe)("error on a notification", function () {
+        (0, mocha_1.beforeEach)(function () {
+            server.addMethod("foo", function () { return Promise.reject(new Error("foo")); });
+            return server
+                .receive({ jsonrpc: _1.JSONRPC, method: "foo" })
+                .then(function (givenResponse) { return (response = givenResponse); });
+        });
+        (0, mocha_1.it)("should not respond", function () {
+            (0, chai_1.expect)(response).to.be.null;
+        });
+    });
+    (0, mocha_1.describe)("responding null to a request", function () {
+        (0, mocha_1.beforeEach)(function () {
+            server.addMethodAdvanced("foo", function () { return Promise.resolve(null); });
+            return server
+                .receive({
+                jsonrpc: _1.JSONRPC,
+                id: 0,
+                method: "foo",
+            })
+                .then(function (givenResponse) { return (response = givenResponse); });
+        });
+        (0, mocha_1.it)("should respond error", function () {
+            (0, chai_1.expect)(response).to.deep.equal({
+                jsonrpc: _1.JSONRPC,
+                id: 0,
+                error: {
+                    code: _1.JSONRPCErrorCode.InternalError,
+                    message: "Internal error",
+                },
+            });
+        });
+    });
+    (0, mocha_1.describe)("receiving a request to an unknown method", function () {
+        (0, mocha_1.beforeEach)(function () {
+            return server
+                .receive({
+                jsonrpc: _1.JSONRPC,
+                id: 0,
+                method: "foo",
+            })
+                .then(function (givenResponse) { return (response = givenResponse); });
+        });
+        (0, mocha_1.it)("should respond error", function () {
+            (0, chai_1.expect)(response).to.deep.equal({
+                jsonrpc: _1.JSONRPC,
+                id: 0,
+                error: {
+                    code: _1.JSONRPCErrorCode.MethodNotFound,
+                    message: "Method not found",
+                },
+            });
+        });
+    });
+    [{}, "", "invalid JSON"].forEach(function (invalidJSON) {
+        (0, mocha_1.describe)("receiving an invalid JSON (".concat(invalidJSON, ")"), function () {
+            var response;
+            (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, server.receiveJSON(invalidJSON)];
+                        case 1:
+                            response = (_a.sent());
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            (0, mocha_1.it)("should respond an error", function () {
+                (0, chai_1.expect)(response.error.code).to.equal(_1.JSONRPCErrorCode.ParseError);
+            });
+        });
+    });
+    [
+        {},
+        { jsonrpc: _1.JSONRPC },
+        { jsonrpc: _1.JSONRPC + "invalid", method: "" },
+    ].forEach(function (invalidRequest) {
+        (0, mocha_1.describe)("receiving an invalid request (".concat(JSON.stringify(invalidRequest), ")"), function () {
+            var response;
+            (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, server.receive(invalidRequest)];
+                        case 1:
+                            response = (_a.sent());
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            (0, mocha_1.it)("should respond an error", function () {
+                (0, chai_1.expect)(response.error.code).to.equal(_1.JSONRPCErrorCode.InvalidRequest);
+            });
+        });
+    });
+    (0, mocha_1.describe)("having a custom mapErrorToJSONRPCErrorResponse method", function () {
+        var errorMessagePrefix;
+        var errorData;
+        (0, mocha_1.beforeEach)(function () {
+            errorMessagePrefix = "Error: ";
+            errorData = {
+                foo: "bar",
+            };
+            server.mapErrorToJSONRPCErrorResponse = function (id, error) {
+                return (0, _1.createJSONRPCErrorResponse)(id, error.code, "".concat(errorMessagePrefix).concat(error.message), errorData);
+            };
+        });
+        (0, mocha_1.describe)("rejecting", function () {
+            var errorCode;
+            var errorMessage;
+            var response;
+            (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            errorCode = 123;
+                            errorMessage = "test message";
+                            server.addMethod("throw", function () {
+                                var error = new Error(errorMessage);
+                                error.code = errorCode;
+                                throw error;
+                            });
+                            return [4 /*yield*/, server.receive({
+                                    jsonrpc: _1.JSONRPC,
+                                    id: 0,
+                                    method: "throw",
+                                })];
+                        case 1:
+                            response = (_a.sent());
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            (0, mocha_1.it)("should respond a custom error code", function () {
+                (0, chai_1.expect)(response.error.code).to.equal(errorCode);
+            });
+            (0, mocha_1.it)("should respond a custom error message", function () {
+                (0, chai_1.expect)(response.error.message).to.equal("".concat(errorMessagePrefix).concat(errorMessage));
+            });
+            (0, mocha_1.it)("should respond a custom error data", function () {
+                (0, chai_1.expect)(response.error.data).to.deep.equal(errorData);
+            });
+        });
+    });
+    (0, mocha_1.describe)("having an async method", function () {
+        var methodName;
+        var receivedRequest;
+        var receivedServerParams;
+        var returnedResponse;
+        var returnFromMethod;
+        var throwFromMethod;
+        (0, mocha_1.beforeEach)(function () {
+            methodName = "foo";
+            server.addMethodAdvanced(methodName, function (request, serverParams) {
+                receivedRequest = request;
+                receivedServerParams = serverParams;
+                return new Promise(function (resolve, reject) {
+                    returnedResponse = {
+                        id: request.id,
+                        jsonrpc: _1.JSONRPC,
+                        result: {
+                            foo: "bar",
+                        },
+                    };
+                    returnFromMethod = function () {
+                        resolve(returnedResponse);
+                    };
+                    throwFromMethod = function (error) {
+                        reject(error);
+                    };
+                });
+            });
+        });
+        (0, mocha_1.describe)("using middleware", function () {
+            var middlewareCalled;
+            var nextReturned;
+            (0, mocha_1.beforeEach)(function () {
+                middlewareCalled = false;
+                nextReturned = false;
+                server.applyMiddleware(function (next, request, serverParams) {
+                    middlewareCalled = true;
+                    return next(request, serverParams).then(function (result) {
+                        nextReturned = true;
+                        return result;
+                    });
+                });
+            });
+            (0, mocha_1.describe)("requesting", function () {
+                var givenRequest;
+                var givenServerParams;
+                var actualResponse;
+                (0, mocha_1.beforeEach)(function () {
+                    givenRequest = {
+                        jsonrpc: _1.JSONRPC,
+                        id: 0,
+                        method: methodName,
+                        params: { foo: "bar" },
+                    };
+                    givenServerParams = { userID: "baz" };
+                    server
+                        .receive(givenRequest, givenServerParams)
+                        .then(function (response) { return (actualResponse = response); });
+                    return consumeAllEvents();
+                });
+                (0, mocha_1.it)("should call the middleware", function () {
+                    (0, chai_1.expect)(middlewareCalled).to.be.true;
+                });
+                (0, mocha_1.it)("should receive a request", function () {
+                    (0, chai_1.expect)(receivedRequest).to.deep.equal(givenRequest);
+                });
+                (0, mocha_1.it)("should received server params", function () {
+                    (0, chai_1.expect)(receivedServerParams).to.deep.equal(givenServerParams);
+                });
+                (0, mocha_1.it)("should not return from the next middleware yet", function () {
+                    (0, chai_1.expect)(nextReturned).to.be.false;
+                });
+                (0, mocha_1.describe)("finishing the request", function () {
+                    (0, mocha_1.beforeEach)(function () {
+                        returnFromMethod();
+                        return consumeAllEvents();
+                    });
+                    (0, mocha_1.it)("should return from the next middleware", function () {
+                        (0, chai_1.expect)(nextReturned).to.be.true;
+                    });
+                    (0, mocha_1.it)("should return a response", function () {
+                        (0, chai_1.expect)(actualResponse).to.deep.equal(returnedResponse);
+                    });
+                });
+            });
+            (0, mocha_1.describe)("using another middleware", function () {
+                var secondMiddlewareCalled;
+                (0, mocha_1.beforeEach)(function () {
+                    secondMiddlewareCalled = false;
+                    server.applyMiddleware(function (next, request, serverParams) {
+                        secondMiddlewareCalled = true;
+                        return next(request, serverParams);
+                    });
+                });
+                (0, mocha_1.describe)("requesting", function () {
+                    (0, mocha_1.beforeEach)(function () {
+                        server.receive({
+                            jsonrpc: _1.JSONRPC,
+                            id: 0,
+                            method: methodName,
+                            params: {},
+                        });
+                    });
+                    (0, mocha_1.it)("should call the first middleware", function () {
+                        (0, chai_1.expect)(middlewareCalled).to.be.true;
+                    });
+                    (0, mocha_1.it)("should call the second middleware", function () {
+                        (0, chai_1.expect)(secondMiddlewareCalled).to.be.true;
+                    });
+                });
+            });
+        });
+        (0, mocha_1.describe)("using a middleware that changes request and server params", function () {
+            var changedParams;
+            var changedServerParams;
+            (0, mocha_1.beforeEach)(function () {
+                changedParams = {
+                    foo: "bar",
+                };
+                changedServerParams = {
+                    userID: "changed user ID",
+                };
+                server.applyMiddleware(function (next, request) {
+                    return next(__assign(__assign({}, request), { params: changedParams }), changedServerParams);
+                });
+            });
+            (0, mocha_1.describe)("requesting", function () {
+                var givenRequest;
+                (0, mocha_1.beforeEach)(function () {
+                    givenRequest = {
+                        jsonrpc: _1.JSONRPC,
+                        id: 0,
+                        method: methodName,
+                        params: {
+                            foo: "foo",
+                        },
+                    };
+                    server.receive(givenRequest);
+                    returnFromMethod();
+                    return consumeAllEvents();
+                });
+                (0, mocha_1.it)("should change the request", function () {
+                    var expectedRequest = __assign(__assign({}, givenRequest), { params: changedParams });
+                    (0, chai_1.expect)(receivedRequest).to.deep.equal(expectedRequest);
+                });
+                (0, mocha_1.it)("should change the server params", function () {
+                    (0, chai_1.expect)(receivedServerParams).to.deep.equal(changedServerParams);
+                });
+            });
+        });
+        (0, mocha_1.describe)("using a middleware that changes response", function () {
+            var changedResponse;
+            (0, mocha_1.beforeEach)(function () {
+                server.applyMiddleware(function (next, request, serverParams) {
+                    return next(request, serverParams).then(function (response) {
+                        changedResponse = {
+                            jsonrpc: _1.JSONRPC,
+                            id: response.id,
+                            result: {
+                                foo: new Date().toString(),
+                            },
+                        };
+                        return changedResponse;
+                    });
+                });
+            });
+            (0, mocha_1.describe)("requesting", function () {
+                var actualResponse;
+                (0, mocha_1.beforeEach)(function () {
+                    server
+                        .receive({
+                        jsonrpc: _1.JSONRPC,
+                        id: 0,
+                        method: methodName,
+                        params: {},
+                    })
+                        .then(function (response) { return (actualResponse = response); });
+                    returnFromMethod();
+                    return consumeAllEvents();
+                });
+                (0, mocha_1.it)("should return the changed response", function () {
+                    (0, chai_1.expect)(actualResponse).to.deep.equal(changedResponse);
+                });
+            });
+        });
+        (0, mocha_1.describe)("using middleware that catches exception", function () {
+            (0, mocha_1.beforeEach)(function () {
+                server.applyMiddleware(function (next, request, serverParams) { return __awaiter(void 0, void 0, void 0, function () {
+                    var error_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, next(request, serverParams)];
+                            case 1: return [2 /*return*/, _a.sent()];
+                            case 2:
+                                error_1 = _a.sent();
+                                return [2 /*return*/, (0, _1.createJSONRPCErrorResponse)(request.id, error_1.code || _1.JSONRPCErrorCode.InternalError, error_1.message)];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+            (0, mocha_1.describe)("throwing", function () {
+                var error;
+                var actualResponse;
+                (0, mocha_1.beforeEach)(function () {
+                    server
+                        .receive({
+                        jsonrpc: _1.JSONRPC,
+                        id: 0,
+                        method: methodName,
+                        params: {},
+                    })
+                        .then(function (response) { return (actualResponse = response); });
+                    error = { code: 123, message: "test" };
+                    throwFromMethod(error);
+                    return consumeAllEvents();
+                });
+                (0, mocha_1.it)("should catch the exception on middleware", function () {
+                    var expected = (0, _1.createJSONRPCErrorResponse)(0, error.code, error.message);
+                    (0, chai_1.expect)(actualResponse).to.deep.equal(expected);
+                });
+            });
+            (0, mocha_1.describe)("throwing from non-advanced method", function () {
+                var message;
+                var code;
+                var actualResponse;
+                (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                message = "thrown from non-advanced method";
+                                code = 456;
+                                server.addMethod("throw", function () { return __awaiter(void 0, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        throw { message: message, code: code };
+                                    });
+                                }); });
+                                return [4 /*yield*/, server.receive({
+                                        jsonrpc: _1.JSONRPC,
+                                        id: 0,
+                                        method: "throw",
+                                    })];
+                            case 1:
+                                actualResponse = (_a.sent());
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                (0, mocha_1.it)("should catch the exception on middleware", function () {
+                    var expected = (0, _1.createJSONRPCErrorResponse)(0, code, message);
+                    (0, chai_1.expect)(actualResponse).to.deep.equal(expected);
+                });
+            });
+        });
+        (0, mocha_1.describe)("using multiple middleware", function () {
+            var count;
+            var first;
+            var second;
+            var third;
+            (0, mocha_1.beforeEach)(function () {
+                count = 0;
+                server.applyMiddleware(function (next, request, serverParams) {
+                    first = ++count;
+                    return next(request, serverParams);
+                }, function (next, request, serverParams) {
+                    second = ++count;
+                    return next(request, serverParams);
+                }, function (next, request, serverParams) {
+                    third = ++count;
+                    return next(request, serverParams);
+                });
+                server.receive({
+                    jsonrpc: _1.JSONRPC,
+                    id: 0,
+                    method: methodName,
+                });
+                return consumeAllEvents();
+            });
+            (0, mocha_1.it)("should call middleware in the applied order", function () {
+                (0, chai_1.expect)([first, second, third]).to.deep.equal([1, 2, 3]);
+            });
+        });
+    });
+    (0, mocha_1.describe)("receiving batch requests", function () {
+        var responses;
+        (0, mocha_1.beforeEach)(function () {
+            server.addMethod("echo", function (_a) {
+                var message = _a.message;
+                return message;
+            });
+        });
+        (0, mocha_1.describe)("of 3 requests", function () {
+            (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, server.receive([
+                                { jsonrpc: _1.JSONRPC, id: 0, method: "echo", params: { message: "1" } },
+                                { jsonrpc: _1.JSONRPC, id: 1, method: "echo", params: { message: "2" } },
+                                { jsonrpc: _1.JSONRPC, id: 2, method: "echo", params: { message: "3" } },
+                            ])];
+                        case 1:
+                            responses = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            (0, mocha_1.it)("should return 3 responses", function () {
+                (0, chai_1.expect)(responses.map(function (response) { return response.result; })).to.deep.equal(["1", "2", "3"]);
+            });
+        });
+        (0, mocha_1.describe)("of 1 request", function () {
+            (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, server.receive([
+                                { jsonrpc: _1.JSONRPC, id: 0, method: "echo", params: { message: "1" } },
+                            ])];
+                        case 1:
+                            responses = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            (0, mocha_1.it)("should return 1 response", function () {
+                (0, chai_1.expect)(responses.result).to.equal("1");
+            });
+        });
+        (0, mocha_1.describe)("of notifications", function () {
+            (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, server.receive([
+                                { jsonrpc: _1.JSONRPC, method: "echo", params: { message: "1" } },
+                            ])];
+                        case 1:
+                            responses = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            (0, mocha_1.it)("should return null", function () {
+                (0, chai_1.expect)(responses).to.be.null;
+            });
+        });
+        (0, mocha_1.describe)("of a valid and an invalid request", function () {
+            (0, mocha_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, server.receive([
+                                1,
+                                { jsonrpc: _1.JSONRPC, id: 0, method: "echo", params: { message: "1" } },
+                            ])];
+                        case 1:
+                            responses = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            (0, mocha_1.it)("should return a failure and a success response", function () {
+                (0, chai_1.expect)(responses).to.deep.equal([
+                    {
+                        jsonrpc: _1.JSONRPC,
+                        id: null,
+                        error: {
+                            code: _1.JSONRPCErrorCode.InvalidRequest,
+                            message: "Invalid Request",
+                        },
+                    },
+                    { jsonrpc: _1.JSONRPC, id: 0, result: "1" },
+                ]);
+            });
+        });
+    });
+});
+var consumeAllEvents = function () { return new Promise(function (resolve) { return setTimeout(resolve, 0); }); };

node_modules/json-rpc-2.0/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "json-rpc-2.0",
+  "version": "1.7.0",
+  "description": "JSON-RPC 2.0 client and server",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "format": "pretty-quick || echo \"Failed to format. Continuing...\"",
+    "test": "npm run format && mocha --require ts-node/register \"./src/**/*.spec.ts\"",
+    "clean": "del \"dist\"",
+    "build": "npm run format && npm run clean && tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shogowada/json-rpc-2.0.git"
+  },
+  "keywords": [
+    "json-rpc"
+  ],
+  "author": "Shogo Wada",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/shogowada/json-rpc-2.0/issues"
+  },
+  "homepage": "https://github.com/shogowada/json-rpc-2.0#readme",
+  "devDependencies": {
+    "@types/chai": "^4.3.0",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "^14.18.12",
+    "@types/sinon": "^10.0.11",
+    "chai": "^4.3.6",
+    "del-cli": "^3.0.1",
+    "mocha": "^9.2.2",
+    "prettier": "^2.6.1",
+    "pretty-quick": "^3.1.3",
+    "sinon": "^10.0.0",
+    "ts-node": "^7.0.1",
+    "typescript": "^4.9.3"
+  }
+}