diff --git a/.azure/pipelines/ci.yml b/.azure/pipelines/ci.yml
index f0a760d1f1..c84579b8d4 100644
--- a/.azure/pipelines/ci.yml
+++ b/.azure/pipelines/ci.yml
@@ -24,7 +24,6 @@ jobs:
jobDisplayName: Code check
agentOs: Windows
installJdk: false
- installNodeJs: false
steps:
- powershell: ./eng/scripts/CodeCheck.ps1 -ci
displayName: Run eng/scripts/CodeCheck.ps1
diff --git a/eng/scripts/CodeCheck.ps1 b/eng/scripts/CodeCheck.ps1
index 4b60cd6f22..0289fb699d 100644
--- a/eng/scripts/CodeCheck.ps1
+++ b/eng/scripts/CodeCheck.ps1
@@ -130,6 +130,11 @@ try {
& $dotnet run -p "$repoRoot/eng/tools/BaselineGenerator/"
}
+ Write-Host "Re-generating Browser.JS files"
+ Invoke-Block {
+ & $dotnet build "$repoRoot\src\Components\Browser.JS\Microsoft.AspNetCore.Components.Browser.JS.npmproj"
+ }
+
Write-Host "Run git diff to check for pending changes"
# Redirect stderr to stdout because PowerShell does not consistently handle output to stderr
diff --git a/eng/targets/Npm.Common.targets b/eng/targets/Npm.Common.targets
index 4138c08933..fde4fece5c 100644
--- a/eng/targets/Npm.Common.targets
+++ b/eng/targets/Npm.Common.targets
@@ -18,7 +18,7 @@
-
+
diff --git a/src/Components/Blazor/Build/src/Microsoft.AspNetCore.Blazor.Build.csproj b/src/Components/Blazor/Build/src/Microsoft.AspNetCore.Blazor.Build.csproj
index c7b5ae6d2f..af75650cb1 100644
--- a/src/Components/Blazor/Build/src/Microsoft.AspNetCore.Blazor.Build.csproj
+++ b/src/Components/Blazor/Build/src/Microsoft.AspNetCore.Blazor.Build.csproj
@@ -24,6 +24,7 @@
false
+ configuration=$(Configuration);
version=$(PackageVersion);
publishDir=$([MSBuild]::NormalizeDirectory($(IntermediatePackDir)));
componentsversion=$(ComponentsPackageVersion);
diff --git a/src/Components/Blazor/Build/src/Microsoft.AspNetCore.Blazor.Build.nuspec b/src/Components/Blazor/Build/src/Microsoft.AspNetCore.Blazor.Build.nuspec
index 71a47fcb6e..78a3bb0111 100644
--- a/src/Components/Blazor/Build/src/Microsoft.AspNetCore.Blazor.Build.nuspec
+++ b/src/Components/Blazor/Build/src/Microsoft.AspNetCore.Blazor.Build.nuspec
@@ -21,6 +21,6 @@
-
+
diff --git a/src/Components/Blazor/Build/src/ReferenceFromSource.props b/src/Components/Blazor/Build/src/ReferenceFromSource.props
index 145ee253f6..209519e932 100644
--- a/src/Components/Blazor/Build/src/ReferenceFromSource.props
+++ b/src/Components/Blazor/Build/src/ReferenceFromSource.props
@@ -11,7 +11,7 @@
true
- $(RepositoryRoot)src\Components\Browser.JS\src\dist\blazor.*.js
+ $(RepositoryRoot)src\Components\Browser.JS\dist\$(Configuration)\blazor.*.js
diff --git a/src/Components/Browser.JS/.gitignore b/src/Components/Browser.JS/.gitignore
index afce87ca65..246b4e11c9 100644
--- a/src/Components/Browser.JS/.gitignore
+++ b/src/Components/Browser.JS/.gitignore
@@ -1,2 +1,2 @@
node_modules/
-dist/
+*.js.map
diff --git a/src/Components/Browser.JS/Microsoft.AspNetCore.Components.Browser.JS.npmproj b/src/Components/Browser.JS/Microsoft.AspNetCore.Components.Browser.JS.npmproj
index 03ffbe8e7a..3635db296c 100644
--- a/src/Components/Browser.JS/Microsoft.AspNetCore.Components.Browser.JS.npmproj
+++ b/src/Components/Browser.JS/Microsoft.AspNetCore.Components.Browser.JS.npmproj
@@ -7,28 +7,23 @@
-
-
-
+
+
+
+
+
-
-
-
-
-
+
+
+
diff --git a/src/Components/Browser.JS/dist/Debug/blazor.server.js b/src/Components/Browser.JS/dist/Debug/blazor.server.js
new file mode 100644
index 0000000000..51fade0f26
--- /dev/null
+++ b/src/Components/Browser.JS/dist/Debug/blazor.server.js
@@ -0,0 +1,14908 @@
+/******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/
+/******/ // Check if module is in cache
+/******/ if(installedModules[moduleId]) {
+/******/ return installedModules[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = modules;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = installedModules;
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ }
+/******/ };
+/******/
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = function(exports) {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/
+/******/ // create a fake namespace object
+/******/ // mode & 1: value is a module id, require it
+/******/ // mode & 2: merge all properties of value into the ns
+/******/ // mode & 4: return value when already ns object
+/******/ // mode & 8|1: behave like require
+/******/ __webpack_require__.t = function(value, mode) {
+/******/ if(mode & 1) value = __webpack_require__(value);
+/******/ if(mode & 8) return value;
+/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ var ns = Object.create(null);
+/******/ __webpack_require__.r(ns);
+/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ return ns;
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = "./Boot.Server.ts");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/BinaryMessageFormat.js":
+/*!****************************************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/BinaryMessageFormat.js ***!
+ \****************************************************************************************/
+/*! exports provided: BinaryMessageFormat */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BinaryMessageFormat", function() { return BinaryMessageFormat; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+// Not exported from index.
+var BinaryMessageFormat = /** @class */ (function () {
+ function BinaryMessageFormat() {
+ }
+ // The length prefix of binary messages is encoded as VarInt. Read the comment in
+ // the BinaryMessageParser.TryParseMessage for details.
+ BinaryMessageFormat.write = function (output) {
+ // msgpack5 uses returns Buffer instead of Uint8Array on IE10 and some other browser
+ // in which case .byteLength does will be undefined
+ var size = output.byteLength || output.length;
+ var lenBuffer = [];
+ do {
+ var sizePart = size & 0x7f;
+ size = size >> 7;
+ if (size > 0) {
+ sizePart |= 0x80;
+ }
+ lenBuffer.push(sizePart);
+ } while (size > 0);
+ // msgpack5 uses returns Buffer instead of Uint8Array on IE10 and some other browser
+ // in which case .byteLength does will be undefined
+ size = output.byteLength || output.length;
+ var buffer = new Uint8Array(lenBuffer.length + size);
+ buffer.set(lenBuffer, 0);
+ buffer.set(output, lenBuffer.length);
+ return buffer.buffer;
+ };
+ BinaryMessageFormat.parse = function (input) {
+ var result = [];
+ var uint8Array = new Uint8Array(input);
+ var maxLengthPrefixSize = 5;
+ var numBitsToShift = [0, 7, 14, 21, 28];
+ for (var offset = 0; offset < input.byteLength;) {
+ var numBytes = 0;
+ var size = 0;
+ var byteRead = void 0;
+ do {
+ byteRead = uint8Array[offset + numBytes];
+ size = size | ((byteRead & 0x7f) << (numBitsToShift[numBytes]));
+ numBytes++;
+ } while (numBytes < Math.min(maxLengthPrefixSize, input.byteLength - offset) && (byteRead & 0x80) !== 0);
+ if ((byteRead & 0x80) !== 0 && numBytes < maxLengthPrefixSize) {
+ throw new Error("Cannot read message size.");
+ }
+ if (numBytes === maxLengthPrefixSize && byteRead > 7) {
+ throw new Error("Messages bigger than 2GB are not supported.");
+ }
+ if (uint8Array.byteLength >= (offset + numBytes + size)) {
+ // IE does not support .slice() so use subarray
+ result.push(uint8Array.slice
+ ? uint8Array.slice(offset + numBytes, offset + numBytes + size)
+ : uint8Array.subarray(offset + numBytes, offset + numBytes + size));
+ }
+ else {
+ throw new Error("Incomplete message.");
+ }
+ offset = offset + numBytes + size;
+ }
+ return result;
+ };
+ return BinaryMessageFormat;
+}());
+
+//# sourceMappingURL=BinaryMessageFormat.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/MessagePackHubProtocol.js":
+/*!*******************************************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/MessagePackHubProtocol.js ***!
+ \*******************************************************************************************/
+/*! exports provided: MessagePackHubProtocol */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MessagePackHubProtocol", function() { return MessagePackHubProtocol; });
+/* harmony import */ var buffer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! buffer */ "../node_modules/buffer/index.js");
+/* harmony import */ var buffer__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(buffer__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var msgpack5__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! msgpack5 */ "../node_modules/msgpack5/index.js");
+/* harmony import */ var msgpack5__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(msgpack5__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @aspnet/signalr */ "../node_modules/@aspnet/signalr/dist/esm/index.js");
+/* harmony import */ var _BinaryMessageFormat__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./BinaryMessageFormat */ "../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/BinaryMessageFormat.js");
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Utils */ "../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/Utils.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+
+
+
+
+// TypeDoc's @inheritDoc and @link don't work across modules :(
+// constant encoding of the ping message
+// see: https://github.com/aspnet/SignalR/blob/dev/specs/HubProtocol.md#ping-message-encoding-1
+// Don't use Uint8Array.from as IE does not support it
+var SERIALIZED_PING_MESSAGE = new Uint8Array([0x91, _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Ping]);
+/** Implements the MessagePack Hub Protocol */
+var MessagePackHubProtocol = /** @class */ (function () {
+ function MessagePackHubProtocol() {
+ /** The name of the protocol. This is used by SignalR to resolve the protocol between the client and server. */
+ this.name = "messagepack";
+ /** The version of the protocol. */
+ this.version = 1;
+ /** The TransferFormat of the protocol. */
+ this.transferFormat = _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["TransferFormat"].Binary;
+ }
+ /** Creates an array of HubMessage objects from the specified serialized representation.
+ *
+ * @param {ArrayBuffer | Buffer} input An ArrayBuffer containing the serialized representation.
+ * @param {ILogger} logger A logger that will be used to log messages that occur during parsing.
+ */
+ MessagePackHubProtocol.prototype.parseMessages = function (input, logger) {
+ // The interface does allow "string" to be passed in, but this implementation does not. So let's throw a useful error.
+ if (!(input instanceof buffer__WEBPACK_IMPORTED_MODULE_0__["Buffer"]) && !(Object(_Utils__WEBPACK_IMPORTED_MODULE_4__["isArrayBuffer"])(input))) {
+ throw new Error("Invalid input for MessagePack hub protocol. Expected an ArrayBuffer or Buffer.");
+ }
+ if (logger === null) {
+ logger = _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["NullLogger"].instance;
+ }
+ var messages = _BinaryMessageFormat__WEBPACK_IMPORTED_MODULE_3__["BinaryMessageFormat"].parse(input);
+ var hubMessages = [];
+ for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
+ var message = messages_1[_i];
+ var parsedMessage = this.parseMessage(message, logger);
+ // Can be null for an unknown message. Unknown message is logged in parseMessage
+ if (parsedMessage) {
+ hubMessages.push(parsedMessage);
+ }
+ }
+ return hubMessages;
+ };
+ /** Writes the specified HubMessage to an ArrayBuffer and returns it.
+ *
+ * @param {HubMessage} message The message to write.
+ * @returns {ArrayBuffer} An ArrayBuffer containing the serialized representation of the message.
+ */
+ MessagePackHubProtocol.prototype.writeMessage = function (message) {
+ switch (message.type) {
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Invocation:
+ return this.writeInvocation(message);
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].StreamInvocation:
+ return this.writeStreamInvocation(message);
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].StreamItem:
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Completion:
+ throw new Error("Writing messages of type '" + message.type + "' is not supported.");
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Ping:
+ return _BinaryMessageFormat__WEBPACK_IMPORTED_MODULE_3__["BinaryMessageFormat"].write(SERIALIZED_PING_MESSAGE);
+ default:
+ throw new Error("Invalid message type.");
+ }
+ };
+ MessagePackHubProtocol.prototype.parseMessage = function (input, logger) {
+ if (input.length === 0) {
+ throw new Error("Invalid payload.");
+ }
+ var msgpack = msgpack5__WEBPACK_IMPORTED_MODULE_1__();
+ var properties = msgpack.decode(buffer__WEBPACK_IMPORTED_MODULE_0__["Buffer"].from(input));
+ if (properties.length === 0 || !(properties instanceof Array)) {
+ throw new Error("Invalid payload.");
+ }
+ var messageType = properties[0];
+ switch (messageType) {
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Invocation:
+ return this.createInvocationMessage(this.readHeaders(properties), properties);
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].StreamItem:
+ return this.createStreamItemMessage(this.readHeaders(properties), properties);
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Completion:
+ return this.createCompletionMessage(this.readHeaders(properties), properties);
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Ping:
+ return this.createPingMessage(properties);
+ case _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Close:
+ return this.createCloseMessage(properties);
+ default:
+ // Future protocol changes can add message types, old clients can ignore them
+ logger.log(_aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Information, "Unknown message type '" + messageType + "' ignored.");
+ return null;
+ }
+ };
+ MessagePackHubProtocol.prototype.createCloseMessage = function (properties) {
+ // check minimum length to allow protocol to add items to the end of objects in future releases
+ if (properties.length < 2) {
+ throw new Error("Invalid payload for Close message.");
+ }
+ return {
+ // Close messages have no headers.
+ error: properties[1],
+ type: _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Close,
+ };
+ };
+ MessagePackHubProtocol.prototype.createPingMessage = function (properties) {
+ // check minimum length to allow protocol to add items to the end of objects in future releases
+ if (properties.length < 1) {
+ throw new Error("Invalid payload for Ping message.");
+ }
+ return {
+ // Ping messages have no headers.
+ type: _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Ping,
+ };
+ };
+ MessagePackHubProtocol.prototype.createInvocationMessage = function (headers, properties) {
+ // check minimum length to allow protocol to add items to the end of objects in future releases
+ if (properties.length < 5) {
+ throw new Error("Invalid payload for Invocation message.");
+ }
+ var invocationId = properties[2];
+ if (invocationId) {
+ return {
+ arguments: properties[4],
+ headers: headers,
+ invocationId: invocationId,
+ target: properties[3],
+ type: _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Invocation,
+ };
+ }
+ else {
+ return {
+ arguments: properties[4],
+ headers: headers,
+ target: properties[3],
+ type: _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Invocation,
+ };
+ }
+ };
+ MessagePackHubProtocol.prototype.createStreamItemMessage = function (headers, properties) {
+ // check minimum length to allow protocol to add items to the end of objects in future releases
+ if (properties.length < 4) {
+ throw new Error("Invalid payload for StreamItem message.");
+ }
+ return {
+ headers: headers,
+ invocationId: properties[2],
+ item: properties[3],
+ type: _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].StreamItem,
+ };
+ };
+ MessagePackHubProtocol.prototype.createCompletionMessage = function (headers, properties) {
+ // check minimum length to allow protocol to add items to the end of objects in future releases
+ if (properties.length < 4) {
+ throw new Error("Invalid payload for Completion message.");
+ }
+ var errorResult = 1;
+ var voidResult = 2;
+ var nonVoidResult = 3;
+ var resultKind = properties[3];
+ if (resultKind !== voidResult && properties.length < 5) {
+ throw new Error("Invalid payload for Completion message.");
+ }
+ var error;
+ var result;
+ switch (resultKind) {
+ case errorResult:
+ error = properties[4];
+ break;
+ case nonVoidResult:
+ result = properties[4];
+ break;
+ }
+ var completionMessage = {
+ error: error,
+ headers: headers,
+ invocationId: properties[2],
+ result: result,
+ type: _aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Completion,
+ };
+ return completionMessage;
+ };
+ MessagePackHubProtocol.prototype.writeInvocation = function (invocationMessage) {
+ var msgpack = msgpack5__WEBPACK_IMPORTED_MODULE_1__();
+ var payload = msgpack.encode([_aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].Invocation, invocationMessage.headers || {}, invocationMessage.invocationId || null,
+ invocationMessage.target, invocationMessage.arguments]);
+ return _BinaryMessageFormat__WEBPACK_IMPORTED_MODULE_3__["BinaryMessageFormat"].write(payload.slice());
+ };
+ MessagePackHubProtocol.prototype.writeStreamInvocation = function (streamInvocationMessage) {
+ var msgpack = msgpack5__WEBPACK_IMPORTED_MODULE_1__();
+ var payload = msgpack.encode([_aspnet_signalr__WEBPACK_IMPORTED_MODULE_2__["MessageType"].StreamInvocation, streamInvocationMessage.headers || {}, streamInvocationMessage.invocationId,
+ streamInvocationMessage.target, streamInvocationMessage.arguments]);
+ return _BinaryMessageFormat__WEBPACK_IMPORTED_MODULE_3__["BinaryMessageFormat"].write(payload.slice());
+ };
+ MessagePackHubProtocol.prototype.readHeaders = function (properties) {
+ var headers = properties[1];
+ if (typeof headers !== "object") {
+ throw new Error("Invalid headers.");
+ }
+ return headers;
+ };
+ return MessagePackHubProtocol;
+}());
+
+//# sourceMappingURL=MessagePackHubProtocol.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/Utils.js":
+/*!**************************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/Utils.js ***!
+ \**************************************************************************/
+/*! exports provided: isArrayBuffer */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isArrayBuffer", function() { return isArrayBuffer; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+// Copied from signalr/Utils.ts
+/** @private */
+function isArrayBuffer(val) {
+ return val && typeof ArrayBuffer !== "undefined" &&
+ (val instanceof ArrayBuffer ||
+ // Sometimes we get an ArrayBuffer that doesn't satisfy instanceof
+ (val.constructor && val.constructor.name === "ArrayBuffer"));
+}
+//# sourceMappingURL=Utils.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/index.js":
+/*!**************************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/index.js ***!
+ \**************************************************************************/
+/*! exports provided: VERSION, MessagePackHubProtocol */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "VERSION", function() { return VERSION; });
+/* harmony import */ var _MessagePackHubProtocol__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./MessagePackHubProtocol */ "../node_modules/@aspnet/signalr-protocol-msgpack/dist/esm/MessagePackHubProtocol.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "MessagePackHubProtocol", function() { return _MessagePackHubProtocol__WEBPACK_IMPORTED_MODULE_0__["MessagePackHubProtocol"]; });
+
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+// Version token that will be replaced by the prepack command
+/** The version of the SignalR Message Pack protocol library. */
+var VERSION = "1.1.0";
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/AbortController.js":
+/*!*******************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/AbortController.js ***!
+ \*******************************************************************/
+/*! exports provided: AbortController */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "AbortController", function() { return AbortController; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+// Rough polyfill of https://developer.mozilla.org/en-US/docs/Web/API/AbortController
+// We don't actually ever use the API being polyfilled, we always use the polyfill because
+// it's a very new API right now.
+// Not exported from index.
+/** @private */
+var AbortController = /** @class */ (function () {
+ function AbortController() {
+ this.isAborted = false;
+ this.onabort = null;
+ }
+ AbortController.prototype.abort = function () {
+ if (!this.isAborted) {
+ this.isAborted = true;
+ if (this.onabort) {
+ this.onabort();
+ }
+ }
+ };
+ Object.defineProperty(AbortController.prototype, "signal", {
+ get: function () {
+ return this;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(AbortController.prototype, "aborted", {
+ get: function () {
+ return this.isAborted;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ return AbortController;
+}());
+
+//# sourceMappingURL=AbortController.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/DefaultHttpClient.js":
+/*!*********************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/DefaultHttpClient.js ***!
+ \*********************************************************************/
+/*! exports provided: DefaultHttpClient */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DefaultHttpClient", function() { return DefaultHttpClient; });
+/* harmony import */ var _Errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Errors */ "../node_modules/@aspnet/signalr/dist/esm/Errors.js");
+/* harmony import */ var _HttpClient__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./HttpClient */ "../node_modules/@aspnet/signalr/dist/esm/HttpClient.js");
+/* harmony import */ var _XhrHttpClient__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./XhrHttpClient */ "../node_modules/@aspnet/signalr/dist/esm/XhrHttpClient.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __extends = (undefined && undefined.__extends) || (function () {
+ var extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+
+
+
+var nodeHttpClientModule;
+if (typeof XMLHttpRequest === "undefined") {
+ // In order to ignore the dynamic require in webpack builds we need to do this magic
+ // @ts-ignore: TS doesn't know about these names
+ var requireFunc = true ? require : undefined;
+ nodeHttpClientModule = requireFunc("./NodeHttpClient");
+}
+/** Default implementation of {@link @aspnet/signalr.HttpClient}. */
+var DefaultHttpClient = /** @class */ (function (_super) {
+ __extends(DefaultHttpClient, _super);
+ /** Creates a new instance of the {@link @aspnet/signalr.DefaultHttpClient}, using the provided {@link @aspnet/signalr.ILogger} to log messages. */
+ function DefaultHttpClient(logger) {
+ var _this = _super.call(this) || this;
+ if (typeof XMLHttpRequest !== "undefined") {
+ _this.httpClient = new _XhrHttpClient__WEBPACK_IMPORTED_MODULE_2__["XhrHttpClient"](logger);
+ }
+ else if (typeof nodeHttpClientModule !== "undefined") {
+ _this.httpClient = new nodeHttpClientModule.NodeHttpClient(logger);
+ }
+ else {
+ throw new Error("No HttpClient could be created.");
+ }
+ return _this;
+ }
+ /** @inheritDoc */
+ DefaultHttpClient.prototype.send = function (request) {
+ // Check that abort was not signaled before calling send
+ if (request.abortSignal && request.abortSignal.aborted) {
+ return Promise.reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["AbortError"]());
+ }
+ if (!request.method) {
+ return Promise.reject(new Error("No method defined."));
+ }
+ if (!request.url) {
+ return Promise.reject(new Error("No url defined."));
+ }
+ return this.httpClient.send(request);
+ };
+ DefaultHttpClient.prototype.getCookieString = function (url) {
+ return this.httpClient.getCookieString(url);
+ };
+ return DefaultHttpClient;
+}(_HttpClient__WEBPACK_IMPORTED_MODULE_1__["HttpClient"]));
+
+//# sourceMappingURL=DefaultHttpClient.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/Errors.js":
+/*!**********************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/Errors.js ***!
+ \**********************************************************/
+/*! exports provided: HttpError, TimeoutError, AbortError */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HttpError", function() { return HttpError; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TimeoutError", function() { return TimeoutError; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "AbortError", function() { return AbortError; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __extends = (undefined && undefined.__extends) || (function () {
+ var extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+/** Error thrown when an HTTP request fails. */
+var HttpError = /** @class */ (function (_super) {
+ __extends(HttpError, _super);
+ /** Constructs a new instance of {@link @aspnet/signalr.HttpError}.
+ *
+ * @param {string} errorMessage A descriptive error message.
+ * @param {number} statusCode The HTTP status code represented by this error.
+ */
+ function HttpError(errorMessage, statusCode) {
+ var _newTarget = this.constructor;
+ var _this = this;
+ var trueProto = _newTarget.prototype;
+ _this = _super.call(this, errorMessage) || this;
+ _this.statusCode = statusCode;
+ // Workaround issue in Typescript compiler
+ // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+ _this.__proto__ = trueProto;
+ return _this;
+ }
+ return HttpError;
+}(Error));
+
+/** Error thrown when a timeout elapses. */
+var TimeoutError = /** @class */ (function (_super) {
+ __extends(TimeoutError, _super);
+ /** Constructs a new instance of {@link @aspnet/signalr.TimeoutError}.
+ *
+ * @param {string} errorMessage A descriptive error message.
+ */
+ function TimeoutError(errorMessage) {
+ var _newTarget = this.constructor;
+ if (errorMessage === void 0) { errorMessage = "A timeout occurred."; }
+ var _this = this;
+ var trueProto = _newTarget.prototype;
+ _this = _super.call(this, errorMessage) || this;
+ // Workaround issue in Typescript compiler
+ // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+ _this.__proto__ = trueProto;
+ return _this;
+ }
+ return TimeoutError;
+}(Error));
+
+/** Error thrown when an action is aborted. */
+var AbortError = /** @class */ (function (_super) {
+ __extends(AbortError, _super);
+ /** Constructs a new instance of {@link AbortError}.
+ *
+ * @param {string} errorMessage A descriptive error message.
+ */
+ function AbortError(errorMessage) {
+ var _newTarget = this.constructor;
+ if (errorMessage === void 0) { errorMessage = "An abort occurred."; }
+ var _this = this;
+ var trueProto = _newTarget.prototype;
+ _this = _super.call(this, errorMessage) || this;
+ // Workaround issue in Typescript compiler
+ // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+ _this.__proto__ = trueProto;
+ return _this;
+ }
+ return AbortError;
+}(Error));
+
+//# sourceMappingURL=Errors.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/HandshakeProtocol.js":
+/*!*********************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/HandshakeProtocol.js ***!
+ \*********************************************************************/
+/*! exports provided: HandshakeProtocol */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* WEBPACK VAR INJECTION */(function(Buffer) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HandshakeProtocol", function() { return HandshakeProtocol; });
+/* harmony import */ var _TextMessageFormat__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TextMessageFormat */ "../node_modules/@aspnet/signalr/dist/esm/TextMessageFormat.js");
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utils */ "../node_modules/@aspnet/signalr/dist/esm/Utils.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+
+/** @private */
+var HandshakeProtocol = /** @class */ (function () {
+ function HandshakeProtocol() {
+ }
+ // Handshake request is always JSON
+ HandshakeProtocol.prototype.writeHandshakeRequest = function (handshakeRequest) {
+ return _TextMessageFormat__WEBPACK_IMPORTED_MODULE_0__["TextMessageFormat"].write(JSON.stringify(handshakeRequest));
+ };
+ HandshakeProtocol.prototype.parseHandshakeResponse = function (data) {
+ var responseMessage;
+ var messageData;
+ var remainingData;
+ if (Object(_Utils__WEBPACK_IMPORTED_MODULE_1__["isArrayBuffer"])(data) || (typeof Buffer !== "undefined" && data instanceof Buffer)) {
+ // Format is binary but still need to read JSON text from handshake response
+ var binaryData = new Uint8Array(data);
+ var separatorIndex = binaryData.indexOf(_TextMessageFormat__WEBPACK_IMPORTED_MODULE_0__["TextMessageFormat"].RecordSeparatorCode);
+ if (separatorIndex === -1) {
+ throw new Error("Message is incomplete.");
+ }
+ // content before separator is handshake response
+ // optional content after is additional messages
+ var responseLength = separatorIndex + 1;
+ messageData = String.fromCharCode.apply(null, binaryData.slice(0, responseLength));
+ remainingData = (binaryData.byteLength > responseLength) ? binaryData.slice(responseLength).buffer : null;
+ }
+ else {
+ var textData = data;
+ var separatorIndex = textData.indexOf(_TextMessageFormat__WEBPACK_IMPORTED_MODULE_0__["TextMessageFormat"].RecordSeparator);
+ if (separatorIndex === -1) {
+ throw new Error("Message is incomplete.");
+ }
+ // content before separator is handshake response
+ // optional content after is additional messages
+ var responseLength = separatorIndex + 1;
+ messageData = textData.substring(0, responseLength);
+ remainingData = (textData.length > responseLength) ? textData.substring(responseLength) : null;
+ }
+ // At this point we should have just the single handshake message
+ var messages = _TextMessageFormat__WEBPACK_IMPORTED_MODULE_0__["TextMessageFormat"].parse(messageData);
+ var response = JSON.parse(messages[0]);
+ if (response.type) {
+ throw new Error("Expected a handshake response from the server.");
+ }
+ responseMessage = response;
+ // multiple messages could have arrived with handshake
+ // return additional data to be parsed as usual, or null if all parsed
+ return [remainingData, responseMessage];
+ };
+ return HandshakeProtocol;
+}());
+
+//# sourceMappingURL=HandshakeProtocol.js.map
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../../buffer/index.js */ "../node_modules/buffer/index.js").Buffer))
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/HttpClient.js":
+/*!**************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/HttpClient.js ***!
+ \**************************************************************/
+/*! exports provided: HttpResponse, HttpClient */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HttpResponse", function() { return HttpResponse; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HttpClient", function() { return HttpClient; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __assign = (undefined && undefined.__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;
+};
+/** Represents an HTTP response. */
+var HttpResponse = /** @class */ (function () {
+ function HttpResponse(statusCode, statusText, content) {
+ this.statusCode = statusCode;
+ this.statusText = statusText;
+ this.content = content;
+ }
+ return HttpResponse;
+}());
+
+/** Abstraction over an HTTP client.
+ *
+ * This class provides an abstraction over an HTTP client so that a different implementation can be provided on different platforms.
+ */
+var HttpClient = /** @class */ (function () {
+ function HttpClient() {
+ }
+ HttpClient.prototype.get = function (url, options) {
+ return this.send(__assign({}, options, { method: "GET", url: url }));
+ };
+ HttpClient.prototype.post = function (url, options) {
+ return this.send(__assign({}, options, { method: "POST", url: url }));
+ };
+ HttpClient.prototype.delete = function (url, options) {
+ return this.send(__assign({}, options, { method: "DELETE", url: url }));
+ };
+ /** Gets all cookies that apply to the specified URL.
+ *
+ * @param url The URL that the cookies are valid for.
+ * @returns {string} A string containing all the key-value cookie pairs for the specified URL.
+ */
+ // @ts-ignore
+ HttpClient.prototype.getCookieString = function (url) {
+ return "";
+ };
+ return HttpClient;
+}());
+
+//# sourceMappingURL=HttpClient.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/HttpConnection.js":
+/*!******************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/HttpConnection.js ***!
+ \******************************************************************/
+/*! exports provided: HttpConnection */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HttpConnection", function() { return HttpConnection; });
+/* harmony import */ var _DefaultHttpClient__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./DefaultHttpClient */ "../node_modules/@aspnet/signalr/dist/esm/DefaultHttpClient.js");
+/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ILogger */ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js");
+/* harmony import */ var _ITransport__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ITransport */ "../node_modules/@aspnet/signalr/dist/esm/ITransport.js");
+/* harmony import */ var _LongPollingTransport__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./LongPollingTransport */ "../node_modules/@aspnet/signalr/dist/esm/LongPollingTransport.js");
+/* harmony import */ var _ServerSentEventsTransport__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./ServerSentEventsTransport */ "../node_modules/@aspnet/signalr/dist/esm/ServerSentEventsTransport.js");
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./Utils */ "../node_modules/@aspnet/signalr/dist/esm/Utils.js");
+/* harmony import */ var _WebSocketTransport__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./WebSocketTransport */ "../node_modules/@aspnet/signalr/dist/esm/WebSocketTransport.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ 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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (undefined && undefined.__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 (_) 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 MAX_REDIRECTS = 100;
+var WebSocketModule = null;
+var EventSourceModule = null;
+if (typeof window === "undefined" && "function" !== "undefined") {
+ // In order to ignore the dynamic require in webpack builds we need to do this magic
+ // @ts-ignore: TS doesn't know about these names
+ var requireFunc = true ? require : undefined;
+ WebSocketModule = requireFunc("ws");
+ EventSourceModule = requireFunc("eventsource");
+}
+/** @private */
+var HttpConnection = /** @class */ (function () {
+ function HttpConnection(url, options) {
+ if (options === void 0) { options = {}; }
+ this.features = {};
+ _Utils__WEBPACK_IMPORTED_MODULE_5__["Arg"].isRequired(url, "url");
+ this.logger = Object(_Utils__WEBPACK_IMPORTED_MODULE_5__["createLogger"])(options.logger);
+ this.baseUrl = this.resolveUrl(url);
+ options = options || {};
+ options.logMessageContent = options.logMessageContent || false;
+ var isNode = typeof window === "undefined";
+ if (!isNode && typeof WebSocket !== "undefined" && !options.WebSocket) {
+ options.WebSocket = WebSocket;
+ }
+ else if (isNode && !options.WebSocket) {
+ if (WebSocketModule) {
+ options.WebSocket = WebSocketModule;
+ }
+ }
+ if (!isNode && typeof EventSource !== "undefined" && !options.EventSource) {
+ options.EventSource = EventSource;
+ }
+ else if (isNode && !options.EventSource) {
+ if (typeof EventSourceModule !== "undefined") {
+ options.EventSource = EventSourceModule;
+ }
+ }
+ this.httpClient = options.httpClient || new _DefaultHttpClient__WEBPACK_IMPORTED_MODULE_0__["DefaultHttpClient"](this.logger);
+ this.connectionState = 2 /* Disconnected */;
+ this.options = options;
+ this.onreceive = null;
+ this.onclose = null;
+ }
+ HttpConnection.prototype.start = function (transferFormat) {
+ transferFormat = transferFormat || _ITransport__WEBPACK_IMPORTED_MODULE_2__["TransferFormat"].Binary;
+ _Utils__WEBPACK_IMPORTED_MODULE_5__["Arg"].isIn(transferFormat, _ITransport__WEBPACK_IMPORTED_MODULE_2__["TransferFormat"], "transferFormat");
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Debug, "Starting connection with transfer format '" + _ITransport__WEBPACK_IMPORTED_MODULE_2__["TransferFormat"][transferFormat] + "'.");
+ if (this.connectionState !== 2 /* Disconnected */) {
+ return Promise.reject(new Error("Cannot start a connection that is not in the 'Disconnected' state."));
+ }
+ this.connectionState = 0 /* Connecting */;
+ this.startPromise = this.startInternal(transferFormat);
+ return this.startPromise;
+ };
+ HttpConnection.prototype.send = function (data) {
+ if (this.connectionState !== 1 /* Connected */) {
+ throw new Error("Cannot send data if the connection is not in the 'Connected' State.");
+ }
+ // Transport will not be null if state is connected
+ return this.transport.send(data);
+ };
+ HttpConnection.prototype.stop = function (error) {
+ return __awaiter(this, void 0, void 0, function () {
+ var e_1;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ this.connectionState = 2 /* Disconnected */;
+ // Set error as soon as possible otherwise there is a race between
+ // the transport closing and providing an error and the error from a close message
+ // We would prefer the close message error.
+ this.stopError = error;
+ _a.label = 1;
+ case 1:
+ _a.trys.push([1, 3, , 4]);
+ return [4 /*yield*/, this.startPromise];
+ case 2:
+ _a.sent();
+ return [3 /*break*/, 4];
+ case 3:
+ e_1 = _a.sent();
+ return [3 /*break*/, 4];
+ case 4:
+ if (!this.transport) return [3 /*break*/, 6];
+ return [4 /*yield*/, this.transport.stop()];
+ case 5:
+ _a.sent();
+ this.transport = undefined;
+ _a.label = 6;
+ case 6: return [2 /*return*/];
+ }
+ });
+ });
+ };
+ HttpConnection.prototype.startInternal = function (transferFormat) {
+ return __awaiter(this, void 0, void 0, function () {
+ var url, negotiateResponse, redirects, _loop_1, this_1, state_1, e_2;
+ var _this = this;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ url = this.baseUrl;
+ this.accessTokenFactory = this.options.accessTokenFactory;
+ _a.label = 1;
+ case 1:
+ _a.trys.push([1, 12, , 13]);
+ if (!this.options.skipNegotiation) return [3 /*break*/, 5];
+ if (!(this.options.transport === _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"].WebSockets)) return [3 /*break*/, 3];
+ // No need to add a connection ID in this case
+ this.transport = this.constructTransport(_ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"].WebSockets);
+ // We should just call connect directly in this case.
+ // No fallback or negotiate in this case.
+ return [4 /*yield*/, this.transport.connect(url, transferFormat)];
+ case 2:
+ // We should just call connect directly in this case.
+ // No fallback or negotiate in this case.
+ _a.sent();
+ return [3 /*break*/, 4];
+ case 3: throw Error("Negotiation can only be skipped when using the WebSocket transport directly.");
+ case 4: return [3 /*break*/, 11];
+ case 5:
+ negotiateResponse = null;
+ redirects = 0;
+ _loop_1 = function () {
+ var accessToken_1;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0: return [4 /*yield*/, this_1.getNegotiationResponse(url)];
+ case 1:
+ negotiateResponse = _a.sent();
+ // the user tries to stop the connection when it is being started
+ if (this_1.connectionState === 2 /* Disconnected */) {
+ return [2 /*return*/, { value: void 0 }];
+ }
+ if (negotiateResponse.error) {
+ throw Error(negotiateResponse.error);
+ }
+ if (negotiateResponse.ProtocolVersion) {
+ throw Error("Detected a connection attempt to an ASP.NET SignalR Server. This client only supports connecting to an ASP.NET Core SignalR Server. See https://aka.ms/signalr-core-differences for details.");
+ }
+ if (negotiateResponse.url) {
+ url = negotiateResponse.url;
+ }
+ if (negotiateResponse.accessToken) {
+ accessToken_1 = negotiateResponse.accessToken;
+ this_1.accessTokenFactory = function () { return accessToken_1; };
+ }
+ redirects++;
+ return [2 /*return*/];
+ }
+ });
+ };
+ this_1 = this;
+ _a.label = 6;
+ case 6: return [5 /*yield**/, _loop_1()];
+ case 7:
+ state_1 = _a.sent();
+ if (typeof state_1 === "object")
+ return [2 /*return*/, state_1.value];
+ _a.label = 8;
+ case 8:
+ if (negotiateResponse.url && redirects < MAX_REDIRECTS) return [3 /*break*/, 6];
+ _a.label = 9;
+ case 9:
+ if (redirects === MAX_REDIRECTS && negotiateResponse.url) {
+ throw Error("Negotiate redirection limit exceeded.");
+ }
+ return [4 /*yield*/, this.createTransport(url, this.options.transport, negotiateResponse, transferFormat)];
+ case 10:
+ _a.sent();
+ _a.label = 11;
+ case 11:
+ if (this.transport instanceof _LongPollingTransport__WEBPACK_IMPORTED_MODULE_3__["LongPollingTransport"]) {
+ this.features.inherentKeepAlive = true;
+ }
+ this.transport.onreceive = this.onreceive;
+ this.transport.onclose = function (e) { return _this.stopConnection(e); };
+ // only change the state if we were connecting to not overwrite
+ // the state if the connection is already marked as Disconnected
+ this.changeState(0 /* Connecting */, 1 /* Connected */);
+ return [3 /*break*/, 13];
+ case 12:
+ e_2 = _a.sent();
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Error, "Failed to start the connection: " + e_2);
+ this.connectionState = 2 /* Disconnected */;
+ this.transport = undefined;
+ throw e_2;
+ case 13: return [2 /*return*/];
+ }
+ });
+ });
+ };
+ HttpConnection.prototype.getNegotiationResponse = function (url) {
+ return __awaiter(this, void 0, void 0, function () {
+ var _a, headers, token, negotiateUrl, response, e_3;
+ return __generator(this, function (_b) {
+ switch (_b.label) {
+ case 0:
+ if (!this.accessTokenFactory) return [3 /*break*/, 2];
+ return [4 /*yield*/, this.accessTokenFactory()];
+ case 1:
+ token = _b.sent();
+ if (token) {
+ headers = (_a = {},
+ _a["Authorization"] = "Bearer " + token,
+ _a);
+ }
+ _b.label = 2;
+ case 2:
+ negotiateUrl = this.resolveNegotiateUrl(url);
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Debug, "Sending negotiation request: " + negotiateUrl + ".");
+ _b.label = 3;
+ case 3:
+ _b.trys.push([3, 5, , 6]);
+ return [4 /*yield*/, this.httpClient.post(negotiateUrl, {
+ content: "",
+ headers: headers,
+ })];
+ case 4:
+ response = _b.sent();
+ if (response.statusCode !== 200) {
+ throw Error("Unexpected status code returned from negotiate " + response.statusCode);
+ }
+ return [2 /*return*/, JSON.parse(response.content)];
+ case 5:
+ e_3 = _b.sent();
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Error, "Failed to complete negotiation with the server: " + e_3);
+ throw e_3;
+ case 6: return [2 /*return*/];
+ }
+ });
+ });
+ };
+ HttpConnection.prototype.createConnectUrl = function (url, connectionId) {
+ if (!connectionId) {
+ return url;
+ }
+ return url + (url.indexOf("?") === -1 ? "?" : "&") + ("id=" + connectionId);
+ };
+ HttpConnection.prototype.createTransport = function (url, requestedTransport, negotiateResponse, requestedTransferFormat) {
+ return __awaiter(this, void 0, void 0, function () {
+ var connectUrl, transports, _i, transports_1, endpoint, transport, ex_1;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ connectUrl = this.createConnectUrl(url, negotiateResponse.connectionId);
+ if (!this.isITransport(requestedTransport)) return [3 /*break*/, 2];
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Debug, "Connection was provided an instance of ITransport, using that directly.");
+ this.transport = requestedTransport;
+ return [4 /*yield*/, this.transport.connect(connectUrl, requestedTransferFormat)];
+ case 1:
+ _a.sent();
+ // only change the state if we were connecting to not overwrite
+ // the state if the connection is already marked as Disconnected
+ this.changeState(0 /* Connecting */, 1 /* Connected */);
+ return [2 /*return*/];
+ case 2:
+ transports = negotiateResponse.availableTransports || [];
+ _i = 0, transports_1 = transports;
+ _a.label = 3;
+ case 3:
+ if (!(_i < transports_1.length)) return [3 /*break*/, 9];
+ endpoint = transports_1[_i];
+ this.connectionState = 0 /* Connecting */;
+ transport = this.resolveTransport(endpoint, requestedTransport, requestedTransferFormat);
+ if (!(typeof transport === "number")) return [3 /*break*/, 8];
+ this.transport = this.constructTransport(transport);
+ if (!!negotiateResponse.connectionId) return [3 /*break*/, 5];
+ return [4 /*yield*/, this.getNegotiationResponse(url)];
+ case 4:
+ negotiateResponse = _a.sent();
+ connectUrl = this.createConnectUrl(url, negotiateResponse.connectionId);
+ _a.label = 5;
+ case 5:
+ _a.trys.push([5, 7, , 8]);
+ return [4 /*yield*/, this.transport.connect(connectUrl, requestedTransferFormat)];
+ case 6:
+ _a.sent();
+ this.changeState(0 /* Connecting */, 1 /* Connected */);
+ return [2 /*return*/];
+ case 7:
+ ex_1 = _a.sent();
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Error, "Failed to start the transport '" + _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"][transport] + "': " + ex_1);
+ this.connectionState = 2 /* Disconnected */;
+ negotiateResponse.connectionId = undefined;
+ return [3 /*break*/, 8];
+ case 8:
+ _i++;
+ return [3 /*break*/, 3];
+ case 9: throw new Error("Unable to initialize any of the available transports.");
+ }
+ });
+ });
+ };
+ HttpConnection.prototype.constructTransport = function (transport) {
+ switch (transport) {
+ case _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"].WebSockets:
+ if (!this.options.WebSocket) {
+ throw new Error("'WebSocket' is not supported in your environment.");
+ }
+ return new _WebSocketTransport__WEBPACK_IMPORTED_MODULE_6__["WebSocketTransport"](this.httpClient, this.accessTokenFactory, this.logger, this.options.logMessageContent || false, this.options.WebSocket);
+ case _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"].ServerSentEvents:
+ if (!this.options.EventSource) {
+ throw new Error("'EventSource' is not supported in your environment.");
+ }
+ return new _ServerSentEventsTransport__WEBPACK_IMPORTED_MODULE_4__["ServerSentEventsTransport"](this.httpClient, this.accessTokenFactory, this.logger, this.options.logMessageContent || false, this.options.EventSource);
+ case _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"].LongPolling:
+ return new _LongPollingTransport__WEBPACK_IMPORTED_MODULE_3__["LongPollingTransport"](this.httpClient, this.accessTokenFactory, this.logger, this.options.logMessageContent || false);
+ default:
+ throw new Error("Unknown transport: " + transport + ".");
+ }
+ };
+ HttpConnection.prototype.resolveTransport = function (endpoint, requestedTransport, requestedTransferFormat) {
+ var transport = _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"][endpoint.transport];
+ if (transport === null || transport === undefined) {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Debug, "Skipping transport '" + endpoint.transport + "' because it is not supported by this client.");
+ }
+ else {
+ var transferFormats = endpoint.transferFormats.map(function (s) { return _ITransport__WEBPACK_IMPORTED_MODULE_2__["TransferFormat"][s]; });
+ if (transportMatches(requestedTransport, transport)) {
+ if (transferFormats.indexOf(requestedTransferFormat) >= 0) {
+ if ((transport === _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"].WebSockets && !this.options.WebSocket) ||
+ (transport === _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"].ServerSentEvents && !this.options.EventSource)) {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Debug, "Skipping transport '" + _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"][transport] + "' because it is not supported in your environment.'");
+ }
+ else {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Debug, "Selecting transport '" + _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"][transport] + "'.");
+ return transport;
+ }
+ }
+ else {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Debug, "Skipping transport '" + _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"][transport] + "' because it does not support the requested transfer format '" + _ITransport__WEBPACK_IMPORTED_MODULE_2__["TransferFormat"][requestedTransferFormat] + "'.");
+ }
+ }
+ else {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Debug, "Skipping transport '" + _ITransport__WEBPACK_IMPORTED_MODULE_2__["HttpTransportType"][transport] + "' because it was disabled by the client.");
+ }
+ }
+ return null;
+ };
+ HttpConnection.prototype.isITransport = function (transport) {
+ return transport && typeof (transport) === "object" && "connect" in transport;
+ };
+ HttpConnection.prototype.changeState = function (from, to) {
+ if (this.connectionState === from) {
+ this.connectionState = to;
+ return true;
+ }
+ return false;
+ };
+ HttpConnection.prototype.stopConnection = function (error) {
+ this.transport = undefined;
+ // If we have a stopError, it takes precedence over the error from the transport
+ error = this.stopError || error;
+ if (error) {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Error, "Connection disconnected with error '" + error + "'.");
+ }
+ else {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Information, "Connection disconnected.");
+ }
+ this.connectionState = 2 /* Disconnected */;
+ if (this.onclose) {
+ this.onclose(error);
+ }
+ };
+ HttpConnection.prototype.resolveUrl = function (url) {
+ // startsWith is not supported in IE
+ if (url.lastIndexOf("https://", 0) === 0 || url.lastIndexOf("http://", 0) === 0) {
+ return url;
+ }
+ if (typeof window === "undefined" || !window || !window.document) {
+ throw new Error("Cannot resolve '" + url + "'.");
+ }
+ // Setting the url to the href propery of an anchor tag handles normalization
+ // for us. There are 3 main cases.
+ // 1. Relative path normalization e.g "b" -> "http://localhost:5000/a/b"
+ // 2. Absolute path normalization e.g "/a/b" -> "http://localhost:5000/a/b"
+ // 3. Networkpath reference normalization e.g "//localhost:5000/a/b" -> "http://localhost:5000/a/b"
+ var aTag = window.document.createElement("a");
+ aTag.href = url;
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Information, "Normalizing '" + url + "' to '" + aTag.href + "'.");
+ return aTag.href;
+ };
+ HttpConnection.prototype.resolveNegotiateUrl = function (url) {
+ var index = url.indexOf("?");
+ var negotiateUrl = url.substring(0, index === -1 ? url.length : index);
+ if (negotiateUrl[negotiateUrl.length - 1] !== "/") {
+ negotiateUrl += "/";
+ }
+ negotiateUrl += "negotiate";
+ negotiateUrl += index === -1 ? "" : url.substring(index);
+ return negotiateUrl;
+ };
+ return HttpConnection;
+}());
+
+function transportMatches(requestedTransport, actualTransport) {
+ return !requestedTransport || ((actualTransport & requestedTransport) !== 0);
+}
+//# sourceMappingURL=HttpConnection.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/HubConnection.js":
+/*!*****************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/HubConnection.js ***!
+ \*****************************************************************/
+/*! exports provided: HubConnectionState, HubConnection */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HubConnectionState", function() { return HubConnectionState; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HubConnection", function() { return HubConnection; });
+/* harmony import */ var _HandshakeProtocol__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./HandshakeProtocol */ "../node_modules/@aspnet/signalr/dist/esm/HandshakeProtocol.js");
+/* harmony import */ var _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./IHubProtocol */ "../node_modules/@aspnet/signalr/dist/esm/IHubProtocol.js");
+/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ILogger */ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js");
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Utils */ "../node_modules/@aspnet/signalr/dist/esm/Utils.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ 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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (undefined && undefined.__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 (_) 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 DEFAULT_TIMEOUT_IN_MS = 30 * 1000;
+var DEFAULT_PING_INTERVAL_IN_MS = 15 * 1000;
+/** Describes the current state of the {@link HubConnection} to the server. */
+var HubConnectionState;
+(function (HubConnectionState) {
+ /** The hub connection is disconnected. */
+ HubConnectionState[HubConnectionState["Disconnected"] = 0] = "Disconnected";
+ /** The hub connection is connected. */
+ HubConnectionState[HubConnectionState["Connected"] = 1] = "Connected";
+})(HubConnectionState || (HubConnectionState = {}));
+/** Represents a connection to a SignalR Hub. */
+var HubConnection = /** @class */ (function () {
+ function HubConnection(connection, logger, protocol) {
+ var _this = this;
+ _Utils__WEBPACK_IMPORTED_MODULE_3__["Arg"].isRequired(connection, "connection");
+ _Utils__WEBPACK_IMPORTED_MODULE_3__["Arg"].isRequired(logger, "logger");
+ _Utils__WEBPACK_IMPORTED_MODULE_3__["Arg"].isRequired(protocol, "protocol");
+ this.serverTimeoutInMilliseconds = DEFAULT_TIMEOUT_IN_MS;
+ this.keepAliveIntervalInMilliseconds = DEFAULT_PING_INTERVAL_IN_MS;
+ this.logger = logger;
+ this.protocol = protocol;
+ this.connection = connection;
+ this.handshakeProtocol = new _HandshakeProtocol__WEBPACK_IMPORTED_MODULE_0__["HandshakeProtocol"]();
+ this.connection.onreceive = function (data) { return _this.processIncomingData(data); };
+ this.connection.onclose = function (error) { return _this.connectionClosed(error); };
+ this.callbacks = {};
+ this.methods = {};
+ this.closedCallbacks = [];
+ this.id = 0;
+ this.receivedHandshakeResponse = false;
+ this.connectionState = HubConnectionState.Disconnected;
+ this.cachedPingMessage = this.protocol.writeMessage({ type: _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Ping });
+ }
+ /** @internal */
+ // Using a public static factory method means we can have a private constructor and an _internal_
+ // create method that can be used by HubConnectionBuilder. An "internal" constructor would just
+ // be stripped away and the '.d.ts' file would have no constructor, which is interpreted as a
+ // public parameter-less constructor.
+ HubConnection.create = function (connection, logger, protocol) {
+ return new HubConnection(connection, logger, protocol);
+ };
+ Object.defineProperty(HubConnection.prototype, "state", {
+ /** Indicates the state of the {@link HubConnection} to the server. */
+ get: function () {
+ return this.connectionState;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ /** Starts the connection.
+ *
+ * @returns {Promise} A Promise that resolves when the connection has been successfully established, or rejects with an error.
+ */
+ HubConnection.prototype.start = function () {
+ return __awaiter(this, void 0, void 0, function () {
+ var handshakeRequest, handshakePromise;
+ var _this = this;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ handshakeRequest = {
+ protocol: this.protocol.name,
+ version: this.protocol.version,
+ };
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Debug, "Starting HubConnection.");
+ this.receivedHandshakeResponse = false;
+ handshakePromise = new Promise(function (resolve, reject) {
+ _this.handshakeResolver = resolve;
+ _this.handshakeRejecter = reject;
+ });
+ return [4 /*yield*/, this.connection.start(this.protocol.transferFormat)];
+ case 1:
+ _a.sent();
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Debug, "Sending handshake request.");
+ return [4 /*yield*/, this.sendMessage(this.handshakeProtocol.writeHandshakeRequest(handshakeRequest))];
+ case 2:
+ _a.sent();
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Information, "Using HubProtocol '" + this.protocol.name + "'.");
+ // defensively cleanup timeout in case we receive a message from the server before we finish start
+ this.cleanupTimeout();
+ this.resetTimeoutPeriod();
+ this.resetKeepAliveInterval();
+ // Wait for the handshake to complete before marking connection as connected
+ return [4 /*yield*/, handshakePromise];
+ case 3:
+ // Wait for the handshake to complete before marking connection as connected
+ _a.sent();
+ this.connectionState = HubConnectionState.Connected;
+ return [2 /*return*/];
+ }
+ });
+ });
+ };
+ /** Stops the connection.
+ *
+ * @returns {Promise} A Promise that resolves when the connection has been successfully terminated, or rejects with an error.
+ */
+ HubConnection.prototype.stop = function () {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Debug, "Stopping HubConnection.");
+ this.cleanupTimeout();
+ this.cleanupPingTimer();
+ return this.connection.stop();
+ };
+ /** Invokes a streaming hub method on the server using the specified name and arguments.
+ *
+ * @typeparam T The type of the items returned by the server.
+ * @param {string} methodName The name of the server method to invoke.
+ * @param {any[]} args The arguments used to invoke the server method.
+ * @returns {IStreamResult} An object that yields results from the server as they are received.
+ */
+ HubConnection.prototype.stream = function (methodName) {
+ var _this = this;
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ var invocationDescriptor = this.createStreamInvocation(methodName, args);
+ var subject = new _Utils__WEBPACK_IMPORTED_MODULE_3__["Subject"](function () {
+ var cancelInvocation = _this.createCancelInvocation(invocationDescriptor.invocationId);
+ var cancelMessage = _this.protocol.writeMessage(cancelInvocation);
+ delete _this.callbacks[invocationDescriptor.invocationId];
+ return _this.sendMessage(cancelMessage);
+ });
+ this.callbacks[invocationDescriptor.invocationId] = function (invocationEvent, error) {
+ if (error) {
+ subject.error(error);
+ return;
+ }
+ else if (invocationEvent) {
+ // invocationEvent will not be null when an error is not passed to the callback
+ if (invocationEvent.type === _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Completion) {
+ if (invocationEvent.error) {
+ subject.error(new Error(invocationEvent.error));
+ }
+ else {
+ subject.complete();
+ }
+ }
+ else {
+ subject.next((invocationEvent.item));
+ }
+ }
+ };
+ var message = this.protocol.writeMessage(invocationDescriptor);
+ this.sendMessage(message)
+ .catch(function (e) {
+ subject.error(e);
+ delete _this.callbacks[invocationDescriptor.invocationId];
+ });
+ return subject;
+ };
+ HubConnection.prototype.sendMessage = function (message) {
+ this.resetKeepAliveInterval();
+ return this.connection.send(message);
+ };
+ /** Invokes a hub method on the server using the specified name and arguments. Does not wait for a response from the receiver.
+ *
+ * The Promise returned by this method resolves when the client has sent the invocation to the server. The server may still
+ * be processing the invocation.
+ *
+ * @param {string} methodName The name of the server method to invoke.
+ * @param {any[]} args The arguments used to invoke the server method.
+ * @returns {Promise} A Promise that resolves when the invocation has been successfully sent, or rejects with an error.
+ */
+ HubConnection.prototype.send = function (methodName) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ var invocationDescriptor = this.createInvocation(methodName, args, true);
+ var message = this.protocol.writeMessage(invocationDescriptor);
+ return this.sendMessage(message);
+ };
+ /** Invokes a hub method on the server using the specified name and arguments.
+ *
+ * The Promise returned by this method resolves when the server indicates it has finished invoking the method. When the promise
+ * resolves, the server has finished invoking the method. If the server method returns a result, it is produced as the result of
+ * resolving the Promise.
+ *
+ * @typeparam T The expected return type.
+ * @param {string} methodName The name of the server method to invoke.
+ * @param {any[]} args The arguments used to invoke the server method.
+ * @returns {Promise} A Promise that resolves with the result of the server method (if any), or rejects with an error.
+ */
+ HubConnection.prototype.invoke = function (methodName) {
+ var _this = this;
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ var invocationDescriptor = this.createInvocation(methodName, args, false);
+ var p = new Promise(function (resolve, reject) {
+ // invocationId will always have a value for a non-blocking invocation
+ _this.callbacks[invocationDescriptor.invocationId] = function (invocationEvent, error) {
+ if (error) {
+ reject(error);
+ return;
+ }
+ else if (invocationEvent) {
+ // invocationEvent will not be null when an error is not passed to the callback
+ if (invocationEvent.type === _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Completion) {
+ if (invocationEvent.error) {
+ reject(new Error(invocationEvent.error));
+ }
+ else {
+ resolve(invocationEvent.result);
+ }
+ }
+ else {
+ reject(new Error("Unexpected message type: " + invocationEvent.type));
+ }
+ }
+ };
+ var message = _this.protocol.writeMessage(invocationDescriptor);
+ _this.sendMessage(message)
+ .catch(function (e) {
+ reject(e);
+ // invocationId will always have a value for a non-blocking invocation
+ delete _this.callbacks[invocationDescriptor.invocationId];
+ });
+ });
+ return p;
+ };
+ /** Registers a handler that will be invoked when the hub method with the specified method name is invoked.
+ *
+ * @param {string} methodName The name of the hub method to define.
+ * @param {Function} newMethod The handler that will be raised when the hub method is invoked.
+ */
+ HubConnection.prototype.on = function (methodName, newMethod) {
+ if (!methodName || !newMethod) {
+ return;
+ }
+ methodName = methodName.toLowerCase();
+ if (!this.methods[methodName]) {
+ this.methods[methodName] = [];
+ }
+ // Preventing adding the same handler multiple times.
+ if (this.methods[methodName].indexOf(newMethod) !== -1) {
+ return;
+ }
+ this.methods[methodName].push(newMethod);
+ };
+ HubConnection.prototype.off = function (methodName, method) {
+ if (!methodName) {
+ return;
+ }
+ methodName = methodName.toLowerCase();
+ var handlers = this.methods[methodName];
+ if (!handlers) {
+ return;
+ }
+ if (method) {
+ var removeIdx = handlers.indexOf(method);
+ if (removeIdx !== -1) {
+ handlers.splice(removeIdx, 1);
+ if (handlers.length === 0) {
+ delete this.methods[methodName];
+ }
+ }
+ }
+ else {
+ delete this.methods[methodName];
+ }
+ };
+ /** Registers a handler that will be invoked when the connection is closed.
+ *
+ * @param {Function} callback The handler that will be invoked when the connection is closed. Optionally receives a single argument containing the error that caused the connection to close (if any).
+ */
+ HubConnection.prototype.onclose = function (callback) {
+ if (callback) {
+ this.closedCallbacks.push(callback);
+ }
+ };
+ HubConnection.prototype.processIncomingData = function (data) {
+ this.cleanupTimeout();
+ if (!this.receivedHandshakeResponse) {
+ data = this.processHandshakeResponse(data);
+ this.receivedHandshakeResponse = true;
+ }
+ // Data may have all been read when processing handshake response
+ if (data) {
+ // Parse the messages
+ var messages = this.protocol.parseMessages(data, this.logger);
+ for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
+ var message = messages_1[_i];
+ switch (message.type) {
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Invocation:
+ this.invokeClientMethod(message);
+ break;
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].StreamItem:
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Completion:
+ var callback = this.callbacks[message.invocationId];
+ if (callback != null) {
+ if (message.type === _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Completion) {
+ delete this.callbacks[message.invocationId];
+ }
+ callback(message);
+ }
+ break;
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Ping:
+ // Don't care about pings
+ break;
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Close:
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Information, "Close message received from server.");
+ // We don't want to wait on the stop itself.
+ // tslint:disable-next-line:no-floating-promises
+ this.connection.stop(message.error ? new Error("Server returned an error on close: " + message.error) : undefined);
+ break;
+ default:
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Warning, "Invalid message type: " + message.type + ".");
+ break;
+ }
+ }
+ }
+ this.resetTimeoutPeriod();
+ };
+ HubConnection.prototype.processHandshakeResponse = function (data) {
+ var _a;
+ var responseMessage;
+ var remainingData;
+ try {
+ _a = this.handshakeProtocol.parseHandshakeResponse(data), remainingData = _a[0], responseMessage = _a[1];
+ }
+ catch (e) {
+ var message = "Error parsing handshake response: " + e;
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Error, message);
+ var error = new Error(message);
+ // We don't want to wait on the stop itself.
+ // tslint:disable-next-line:no-floating-promises
+ this.connection.stop(error);
+ this.handshakeRejecter(error);
+ throw error;
+ }
+ if (responseMessage.error) {
+ var message = "Server returned handshake error: " + responseMessage.error;
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Error, message);
+ this.handshakeRejecter(message);
+ // We don't want to wait on the stop itself.
+ // tslint:disable-next-line:no-floating-promises
+ this.connection.stop(new Error(message));
+ throw new Error(message);
+ }
+ else {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Debug, "Server handshake complete.");
+ }
+ this.handshakeResolver();
+ return remainingData;
+ };
+ HubConnection.prototype.resetKeepAliveInterval = function () {
+ var _this = this;
+ this.cleanupPingTimer();
+ this.pingServerHandle = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+ var _a;
+ return __generator(this, function (_b) {
+ switch (_b.label) {
+ case 0:
+ if (!(this.connectionState === HubConnectionState.Connected)) return [3 /*break*/, 4];
+ _b.label = 1;
+ case 1:
+ _b.trys.push([1, 3, , 4]);
+ return [4 /*yield*/, this.sendMessage(this.cachedPingMessage)];
+ case 2:
+ _b.sent();
+ return [3 /*break*/, 4];
+ case 3:
+ _a = _b.sent();
+ // We don't care about the error. It should be seen elsewhere in the client.
+ // The connection is probably in a bad or closed state now, cleanup the timer so it stops triggering
+ this.cleanupPingTimer();
+ return [3 /*break*/, 4];
+ case 4: return [2 /*return*/];
+ }
+ });
+ }); }, this.keepAliveIntervalInMilliseconds);
+ };
+ HubConnection.prototype.resetTimeoutPeriod = function () {
+ var _this = this;
+ if (!this.connection.features || !this.connection.features.inherentKeepAlive) {
+ // Set the timeout timer
+ this.timeoutHandle = setTimeout(function () { return _this.serverTimeout(); }, this.serverTimeoutInMilliseconds);
+ }
+ };
+ HubConnection.prototype.serverTimeout = function () {
+ // The server hasn't talked to us in a while. It doesn't like us anymore ... :(
+ // Terminate the connection, but we don't need to wait on the promise.
+ // tslint:disable-next-line:no-floating-promises
+ this.connection.stop(new Error("Server timeout elapsed without receiving a message from the server."));
+ };
+ HubConnection.prototype.invokeClientMethod = function (invocationMessage) {
+ var _this = this;
+ var methods = this.methods[invocationMessage.target.toLowerCase()];
+ if (methods) {
+ methods.forEach(function (m) { return m.apply(_this, invocationMessage.arguments); });
+ if (invocationMessage.invocationId) {
+ // This is not supported in v1. So we return an error to avoid blocking the server waiting for the response.
+ var message = "Server requested a response, which is not supported in this version of the client.";
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Error, message);
+ // We don't need to wait on this Promise.
+ // tslint:disable-next-line:no-floating-promises
+ this.connection.stop(new Error(message));
+ }
+ }
+ else {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Warning, "No client method with the name '" + invocationMessage.target + "' found.");
+ }
+ };
+ HubConnection.prototype.connectionClosed = function (error) {
+ var _this = this;
+ var callbacks = this.callbacks;
+ this.callbacks = {};
+ this.connectionState = HubConnectionState.Disconnected;
+ // if handshake is in progress start will be waiting for the handshake promise, so we complete it
+ // if it has already completed this should just noop
+ if (this.handshakeRejecter) {
+ this.handshakeRejecter(error);
+ }
+ Object.keys(callbacks)
+ .forEach(function (key) {
+ var callback = callbacks[key];
+ callback(null, error ? error : new Error("Invocation canceled due to connection being closed."));
+ });
+ this.cleanupTimeout();
+ this.cleanupPingTimer();
+ this.closedCallbacks.forEach(function (c) { return c.apply(_this, [error]); });
+ };
+ HubConnection.prototype.cleanupPingTimer = function () {
+ if (this.pingServerHandle) {
+ clearTimeout(this.pingServerHandle);
+ }
+ };
+ HubConnection.prototype.cleanupTimeout = function () {
+ if (this.timeoutHandle) {
+ clearTimeout(this.timeoutHandle);
+ }
+ };
+ HubConnection.prototype.createInvocation = function (methodName, args, nonblocking) {
+ if (nonblocking) {
+ return {
+ arguments: args,
+ target: methodName,
+ type: _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Invocation,
+ };
+ }
+ else {
+ var id = this.id;
+ this.id++;
+ return {
+ arguments: args,
+ invocationId: id.toString(),
+ target: methodName,
+ type: _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].Invocation,
+ };
+ }
+ };
+ HubConnection.prototype.createStreamInvocation = function (methodName, args) {
+ var id = this.id;
+ this.id++;
+ return {
+ arguments: args,
+ invocationId: id.toString(),
+ target: methodName,
+ type: _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].StreamInvocation,
+ };
+ };
+ HubConnection.prototype.createCancelInvocation = function (id) {
+ return {
+ invocationId: id,
+ type: _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__["MessageType"].CancelInvocation,
+ };
+ };
+ return HubConnection;
+}());
+
+//# sourceMappingURL=HubConnection.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/HubConnectionBuilder.js":
+/*!************************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/HubConnectionBuilder.js ***!
+ \************************************************************************/
+/*! exports provided: HubConnectionBuilder */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HubConnectionBuilder", function() { return HubConnectionBuilder; });
+/* harmony import */ var _HttpConnection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./HttpConnection */ "../node_modules/@aspnet/signalr/dist/esm/HttpConnection.js");
+/* harmony import */ var _HubConnection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./HubConnection */ "../node_modules/@aspnet/signalr/dist/esm/HubConnection.js");
+/* harmony import */ var _JsonHubProtocol__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./JsonHubProtocol */ "../node_modules/@aspnet/signalr/dist/esm/JsonHubProtocol.js");
+/* harmony import */ var _Loggers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Loggers */ "../node_modules/@aspnet/signalr/dist/esm/Loggers.js");
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Utils */ "../node_modules/@aspnet/signalr/dist/esm/Utils.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+
+
+
+
+/** A builder for configuring {@link @aspnet/signalr.HubConnection} instances. */
+var HubConnectionBuilder = /** @class */ (function () {
+ function HubConnectionBuilder() {
+ }
+ HubConnectionBuilder.prototype.configureLogging = function (logging) {
+ _Utils__WEBPACK_IMPORTED_MODULE_4__["Arg"].isRequired(logging, "logging");
+ if (isLogger(logging)) {
+ this.logger = logging;
+ }
+ else {
+ this.logger = new _Utils__WEBPACK_IMPORTED_MODULE_4__["ConsoleLogger"](logging);
+ }
+ return this;
+ };
+ HubConnectionBuilder.prototype.withUrl = function (url, transportTypeOrOptions) {
+ _Utils__WEBPACK_IMPORTED_MODULE_4__["Arg"].isRequired(url, "url");
+ this.url = url;
+ // Flow-typing knows where it's at. Since HttpTransportType is a number and IHttpConnectionOptions is guaranteed
+ // to be an object, we know (as does TypeScript) this comparison is all we need to figure out which overload was called.
+ if (typeof transportTypeOrOptions === "object") {
+ this.httpConnectionOptions = transportTypeOrOptions;
+ }
+ else {
+ this.httpConnectionOptions = {
+ transport: transportTypeOrOptions,
+ };
+ }
+ return this;
+ };
+ /** Configures the {@link @aspnet/signalr.HubConnection} to use the specified Hub Protocol.
+ *
+ * @param {IHubProtocol} protocol The {@link @aspnet/signalr.IHubProtocol} implementation to use.
+ */
+ HubConnectionBuilder.prototype.withHubProtocol = function (protocol) {
+ _Utils__WEBPACK_IMPORTED_MODULE_4__["Arg"].isRequired(protocol, "protocol");
+ this.protocol = protocol;
+ return this;
+ };
+ /** Creates a {@link @aspnet/signalr.HubConnection} from the configuration options specified in this builder.
+ *
+ * @returns {HubConnection} The configured {@link @aspnet/signalr.HubConnection}.
+ */
+ HubConnectionBuilder.prototype.build = function () {
+ // If httpConnectionOptions has a logger, use it. Otherwise, override it with the one
+ // provided to configureLogger
+ var httpConnectionOptions = this.httpConnectionOptions || {};
+ // If it's 'null', the user **explicitly** asked for null, don't mess with it.
+ if (httpConnectionOptions.logger === undefined) {
+ // If our logger is undefined or null, that's OK, the HttpConnection constructor will handle it.
+ httpConnectionOptions.logger = this.logger;
+ }
+ // Now create the connection
+ if (!this.url) {
+ throw new Error("The 'HubConnectionBuilder.withUrl' method must be called before building the connection.");
+ }
+ var connection = new _HttpConnection__WEBPACK_IMPORTED_MODULE_0__["HttpConnection"](this.url, httpConnectionOptions);
+ return _HubConnection__WEBPACK_IMPORTED_MODULE_1__["HubConnection"].create(connection, this.logger || _Loggers__WEBPACK_IMPORTED_MODULE_3__["NullLogger"].instance, this.protocol || new _JsonHubProtocol__WEBPACK_IMPORTED_MODULE_2__["JsonHubProtocol"]());
+ };
+ return HubConnectionBuilder;
+}());
+
+function isLogger(logger) {
+ return logger.log !== undefined;
+}
+//# sourceMappingURL=HubConnectionBuilder.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/IHubProtocol.js":
+/*!****************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/IHubProtocol.js ***!
+ \****************************************************************/
+/*! exports provided: MessageType */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MessageType", function() { return MessageType; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+/** Defines the type of a Hub Message. */
+var MessageType;
+(function (MessageType) {
+ /** Indicates the message is an Invocation message and implements the {@link @aspnet/signalr.InvocationMessage} interface. */
+ MessageType[MessageType["Invocation"] = 1] = "Invocation";
+ /** Indicates the message is a StreamItem message and implements the {@link @aspnet/signalr.StreamItemMessage} interface. */
+ MessageType[MessageType["StreamItem"] = 2] = "StreamItem";
+ /** Indicates the message is a Completion message and implements the {@link @aspnet/signalr.CompletionMessage} interface. */
+ MessageType[MessageType["Completion"] = 3] = "Completion";
+ /** Indicates the message is a Stream Invocation message and implements the {@link @aspnet/signalr.StreamInvocationMessage} interface. */
+ MessageType[MessageType["StreamInvocation"] = 4] = "StreamInvocation";
+ /** Indicates the message is a Cancel Invocation message and implements the {@link @aspnet/signalr.CancelInvocationMessage} interface. */
+ MessageType[MessageType["CancelInvocation"] = 5] = "CancelInvocation";
+ /** Indicates the message is a Ping message and implements the {@link @aspnet/signalr.PingMessage} interface. */
+ MessageType[MessageType["Ping"] = 6] = "Ping";
+ /** Indicates the message is a Close message and implements the {@link @aspnet/signalr.CloseMessage} interface. */
+ MessageType[MessageType["Close"] = 7] = "Close";
+})(MessageType || (MessageType = {}));
+//# sourceMappingURL=IHubProtocol.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js":
+/*!***********************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/ILogger.js ***!
+ \***********************************************************/
+/*! exports provided: LogLevel */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LogLevel", function() { return LogLevel; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+// These values are designed to match the ASP.NET Log Levels since that's the pattern we're emulating here.
+/** Indicates the severity of a log message.
+ *
+ * Log Levels are ordered in increasing severity. So `Debug` is more severe than `Trace`, etc.
+ */
+var LogLevel;
+(function (LogLevel) {
+ /** Log level for very low severity diagnostic messages. */
+ LogLevel[LogLevel["Trace"] = 0] = "Trace";
+ /** Log level for low severity diagnostic messages. */
+ LogLevel[LogLevel["Debug"] = 1] = "Debug";
+ /** Log level for informational diagnostic messages. */
+ LogLevel[LogLevel["Information"] = 2] = "Information";
+ /** Log level for diagnostic messages that indicate a non-fatal problem. */
+ LogLevel[LogLevel["Warning"] = 3] = "Warning";
+ /** Log level for diagnostic messages that indicate a failure in the current operation. */
+ LogLevel[LogLevel["Error"] = 4] = "Error";
+ /** Log level for diagnostic messages that indicate a failure that will terminate the entire application. */
+ LogLevel[LogLevel["Critical"] = 5] = "Critical";
+ /** The highest possible log level. Used when configuring logging to indicate that no log messages should be emitted. */
+ LogLevel[LogLevel["None"] = 6] = "None";
+})(LogLevel || (LogLevel = {}));
+//# sourceMappingURL=ILogger.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/ITransport.js":
+/*!**************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/ITransport.js ***!
+ \**************************************************************/
+/*! exports provided: HttpTransportType, TransferFormat */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HttpTransportType", function() { return HttpTransportType; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TransferFormat", function() { return TransferFormat; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+// This will be treated as a bit flag in the future, so we keep it using power-of-two values.
+/** Specifies a specific HTTP transport type. */
+var HttpTransportType;
+(function (HttpTransportType) {
+ /** Specifies no transport preference. */
+ HttpTransportType[HttpTransportType["None"] = 0] = "None";
+ /** Specifies the WebSockets transport. */
+ HttpTransportType[HttpTransportType["WebSockets"] = 1] = "WebSockets";
+ /** Specifies the Server-Sent Events transport. */
+ HttpTransportType[HttpTransportType["ServerSentEvents"] = 2] = "ServerSentEvents";
+ /** Specifies the Long Polling transport. */
+ HttpTransportType[HttpTransportType["LongPolling"] = 4] = "LongPolling";
+})(HttpTransportType || (HttpTransportType = {}));
+/** Specifies the transfer format for a connection. */
+var TransferFormat;
+(function (TransferFormat) {
+ /** Specifies that only text data will be transmitted over the connection. */
+ TransferFormat[TransferFormat["Text"] = 1] = "Text";
+ /** Specifies that binary data will be transmitted over the connection. */
+ TransferFormat[TransferFormat["Binary"] = 2] = "Binary";
+})(TransferFormat || (TransferFormat = {}));
+//# sourceMappingURL=ITransport.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/JsonHubProtocol.js":
+/*!*******************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/JsonHubProtocol.js ***!
+ \*******************************************************************/
+/*! exports provided: JsonHubProtocol */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "JsonHubProtocol", function() { return JsonHubProtocol; });
+/* harmony import */ var _IHubProtocol__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./IHubProtocol */ "../node_modules/@aspnet/signalr/dist/esm/IHubProtocol.js");
+/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ILogger */ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js");
+/* harmony import */ var _ITransport__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ITransport */ "../node_modules/@aspnet/signalr/dist/esm/ITransport.js");
+/* harmony import */ var _Loggers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Loggers */ "../node_modules/@aspnet/signalr/dist/esm/Loggers.js");
+/* harmony import */ var _TextMessageFormat__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./TextMessageFormat */ "../node_modules/@aspnet/signalr/dist/esm/TextMessageFormat.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+
+
+
+
+var JSON_HUB_PROTOCOL_NAME = "json";
+/** Implements the JSON Hub Protocol. */
+var JsonHubProtocol = /** @class */ (function () {
+ function JsonHubProtocol() {
+ /** @inheritDoc */
+ this.name = JSON_HUB_PROTOCOL_NAME;
+ /** @inheritDoc */
+ this.version = 1;
+ /** @inheritDoc */
+ this.transferFormat = _ITransport__WEBPACK_IMPORTED_MODULE_2__["TransferFormat"].Text;
+ }
+ /** Creates an array of {@link @aspnet/signalr.HubMessage} objects from the specified serialized representation.
+ *
+ * @param {string} input A string containing the serialized representation.
+ * @param {ILogger} logger A logger that will be used to log messages that occur during parsing.
+ */
+ JsonHubProtocol.prototype.parseMessages = function (input, logger) {
+ // The interface does allow "ArrayBuffer" to be passed in, but this implementation does not. So let's throw a useful error.
+ if (typeof input !== "string") {
+ throw new Error("Invalid input for JSON hub protocol. Expected a string.");
+ }
+ if (!input) {
+ return [];
+ }
+ if (logger === null) {
+ logger = _Loggers__WEBPACK_IMPORTED_MODULE_3__["NullLogger"].instance;
+ }
+ // Parse the messages
+ var messages = _TextMessageFormat__WEBPACK_IMPORTED_MODULE_4__["TextMessageFormat"].parse(input);
+ var hubMessages = [];
+ for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
+ var message = messages_1[_i];
+ var parsedMessage = JSON.parse(message);
+ if (typeof parsedMessage.type !== "number") {
+ throw new Error("Invalid payload.");
+ }
+ switch (parsedMessage.type) {
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_0__["MessageType"].Invocation:
+ this.isInvocationMessage(parsedMessage);
+ break;
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_0__["MessageType"].StreamItem:
+ this.isStreamItemMessage(parsedMessage);
+ break;
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_0__["MessageType"].Completion:
+ this.isCompletionMessage(parsedMessage);
+ break;
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_0__["MessageType"].Ping:
+ // Single value, no need to validate
+ break;
+ case _IHubProtocol__WEBPACK_IMPORTED_MODULE_0__["MessageType"].Close:
+ // All optional values, no need to validate
+ break;
+ default:
+ // Future protocol changes can add message types, old clients can ignore them
+ logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_1__["LogLevel"].Information, "Unknown message type '" + parsedMessage.type + "' ignored.");
+ continue;
+ }
+ hubMessages.push(parsedMessage);
+ }
+ return hubMessages;
+ };
+ /** Writes the specified {@link @aspnet/signalr.HubMessage} to a string and returns it.
+ *
+ * @param {HubMessage} message The message to write.
+ * @returns {string} A string containing the serialized representation of the message.
+ */
+ JsonHubProtocol.prototype.writeMessage = function (message) {
+ return _TextMessageFormat__WEBPACK_IMPORTED_MODULE_4__["TextMessageFormat"].write(JSON.stringify(message));
+ };
+ JsonHubProtocol.prototype.isInvocationMessage = function (message) {
+ this.assertNotEmptyString(message.target, "Invalid payload for Invocation message.");
+ if (message.invocationId !== undefined) {
+ this.assertNotEmptyString(message.invocationId, "Invalid payload for Invocation message.");
+ }
+ };
+ JsonHubProtocol.prototype.isStreamItemMessage = function (message) {
+ this.assertNotEmptyString(message.invocationId, "Invalid payload for StreamItem message.");
+ if (message.item === undefined) {
+ throw new Error("Invalid payload for StreamItem message.");
+ }
+ };
+ JsonHubProtocol.prototype.isCompletionMessage = function (message) {
+ if (message.result && message.error) {
+ throw new Error("Invalid payload for Completion message.");
+ }
+ if (!message.result && message.error) {
+ this.assertNotEmptyString(message.error, "Invalid payload for Completion message.");
+ }
+ this.assertNotEmptyString(message.invocationId, "Invalid payload for Completion message.");
+ };
+ JsonHubProtocol.prototype.assertNotEmptyString = function (value, errorMessage) {
+ if (typeof value !== "string" || value === "") {
+ throw new Error(errorMessage);
+ }
+ };
+ return JsonHubProtocol;
+}());
+
+//# sourceMappingURL=JsonHubProtocol.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/Loggers.js":
+/*!***********************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/Loggers.js ***!
+ \***********************************************************/
+/*! exports provided: NullLogger */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "NullLogger", function() { return NullLogger; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+/** A logger that does nothing when log messages are sent to it. */
+var NullLogger = /** @class */ (function () {
+ function NullLogger() {
+ }
+ /** @inheritDoc */
+ // tslint:disable-next-line
+ NullLogger.prototype.log = function (_logLevel, _message) {
+ };
+ /** The singleton instance of the {@link @aspnet/signalr.NullLogger}. */
+ NullLogger.instance = new NullLogger();
+ return NullLogger;
+}());
+
+//# sourceMappingURL=Loggers.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/LongPollingTransport.js":
+/*!************************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/LongPollingTransport.js ***!
+ \************************************************************************/
+/*! exports provided: LongPollingTransport */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LongPollingTransport", function() { return LongPollingTransport; });
+/* harmony import */ var _AbortController__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AbortController */ "../node_modules/@aspnet/signalr/dist/esm/AbortController.js");
+/* harmony import */ var _Errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Errors */ "../node_modules/@aspnet/signalr/dist/esm/Errors.js");
+/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ILogger */ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js");
+/* harmony import */ var _ITransport__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./ITransport */ "../node_modules/@aspnet/signalr/dist/esm/ITransport.js");
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Utils */ "../node_modules/@aspnet/signalr/dist/esm/Utils.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ 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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (undefined && undefined.__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 (_) 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 };
+ }
+};
+
+
+
+
+
+// Not exported from 'index', this type is internal.
+/** @private */
+var LongPollingTransport = /** @class */ (function () {
+ function LongPollingTransport(httpClient, accessTokenFactory, logger, logMessageContent) {
+ this.httpClient = httpClient;
+ this.accessTokenFactory = accessTokenFactory;
+ this.logger = logger;
+ this.pollAbort = new _AbortController__WEBPACK_IMPORTED_MODULE_0__["AbortController"]();
+ this.logMessageContent = logMessageContent;
+ this.running = false;
+ this.onreceive = null;
+ this.onclose = null;
+ }
+ Object.defineProperty(LongPollingTransport.prototype, "pollAborted", {
+ // This is an internal type, not exported from 'index' so this is really just internal.
+ get: function () {
+ return this.pollAbort.aborted;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ LongPollingTransport.prototype.connect = function (url, transferFormat) {
+ return __awaiter(this, void 0, void 0, function () {
+ var pollOptions, token, pollUrl, response;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ _Utils__WEBPACK_IMPORTED_MODULE_4__["Arg"].isRequired(url, "url");
+ _Utils__WEBPACK_IMPORTED_MODULE_4__["Arg"].isRequired(transferFormat, "transferFormat");
+ _Utils__WEBPACK_IMPORTED_MODULE_4__["Arg"].isIn(transferFormat, _ITransport__WEBPACK_IMPORTED_MODULE_3__["TransferFormat"], "transferFormat");
+ this.url = url;
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) Connecting.");
+ // Allow binary format on Node and Browsers that support binary content (indicated by the presence of responseType property)
+ if (transferFormat === _ITransport__WEBPACK_IMPORTED_MODULE_3__["TransferFormat"].Binary &&
+ (typeof XMLHttpRequest !== "undefined" && typeof new XMLHttpRequest().responseType !== "string")) {
+ throw new Error("Binary protocols over XmlHttpRequest not implementing advanced features are not supported.");
+ }
+ pollOptions = {
+ abortSignal: this.pollAbort.signal,
+ headers: {},
+ timeout: 100000,
+ };
+ if (transferFormat === _ITransport__WEBPACK_IMPORTED_MODULE_3__["TransferFormat"].Binary) {
+ pollOptions.responseType = "arraybuffer";
+ }
+ return [4 /*yield*/, this.getAccessToken()];
+ case 1:
+ token = _a.sent();
+ this.updateHeaderToken(pollOptions, token);
+ pollUrl = url + "&_=" + Date.now();
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) polling: " + pollUrl + ".");
+ return [4 /*yield*/, this.httpClient.get(pollUrl, pollOptions)];
+ case 2:
+ response = _a.sent();
+ if (response.statusCode !== 200) {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Error, "(LongPolling transport) Unexpected response code: " + response.statusCode + ".");
+ // Mark running as false so that the poll immediately ends and runs the close logic
+ this.closeError = new _Errors__WEBPACK_IMPORTED_MODULE_1__["HttpError"](response.statusText || "", response.statusCode);
+ this.running = false;
+ }
+ else {
+ this.running = true;
+ }
+ this.receiving = this.poll(this.url, pollOptions);
+ return [2 /*return*/];
+ }
+ });
+ });
+ };
+ LongPollingTransport.prototype.getAccessToken = function () {
+ return __awaiter(this, void 0, void 0, function () {
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ if (!this.accessTokenFactory) return [3 /*break*/, 2];
+ return [4 /*yield*/, this.accessTokenFactory()];
+ case 1: return [2 /*return*/, _a.sent()];
+ case 2: return [2 /*return*/, null];
+ }
+ });
+ });
+ };
+ LongPollingTransport.prototype.updateHeaderToken = function (request, token) {
+ if (!request.headers) {
+ request.headers = {};
+ }
+ if (token) {
+ // tslint:disable-next-line:no-string-literal
+ request.headers["Authorization"] = "Bearer " + token;
+ return;
+ }
+ // tslint:disable-next-line:no-string-literal
+ if (request.headers["Authorization"]) {
+ // tslint:disable-next-line:no-string-literal
+ delete request.headers["Authorization"];
+ }
+ };
+ LongPollingTransport.prototype.poll = function (url, pollOptions) {
+ return __awaiter(this, void 0, void 0, function () {
+ var token, pollUrl, response, e_1;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ _a.trys.push([0, , 8, 9]);
+ _a.label = 1;
+ case 1:
+ if (!this.running) return [3 /*break*/, 7];
+ return [4 /*yield*/, this.getAccessToken()];
+ case 2:
+ token = _a.sent();
+ this.updateHeaderToken(pollOptions, token);
+ _a.label = 3;
+ case 3:
+ _a.trys.push([3, 5, , 6]);
+ pollUrl = url + "&_=" + Date.now();
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) polling: " + pollUrl + ".");
+ return [4 /*yield*/, this.httpClient.get(pollUrl, pollOptions)];
+ case 4:
+ response = _a.sent();
+ if (response.statusCode === 204) {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Information, "(LongPolling transport) Poll terminated by server.");
+ this.running = false;
+ }
+ else if (response.statusCode !== 200) {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Error, "(LongPolling transport) Unexpected response code: " + response.statusCode + ".");
+ // Unexpected status code
+ this.closeError = new _Errors__WEBPACK_IMPORTED_MODULE_1__["HttpError"](response.statusText || "", response.statusCode);
+ this.running = false;
+ }
+ else {
+ // Process the response
+ if (response.content) {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) data received. " + Object(_Utils__WEBPACK_IMPORTED_MODULE_4__["getDataDetail"])(response.content, this.logMessageContent) + ".");
+ if (this.onreceive) {
+ this.onreceive(response.content);
+ }
+ }
+ else {
+ // This is another way timeout manifest.
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) Poll timed out, reissuing.");
+ }
+ }
+ return [3 /*break*/, 6];
+ case 5:
+ e_1 = _a.sent();
+ if (!this.running) {
+ // Log but disregard errors that occur after stopping
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) Poll errored after shutdown: " + e_1.message);
+ }
+ else {
+ if (e_1 instanceof _Errors__WEBPACK_IMPORTED_MODULE_1__["TimeoutError"]) {
+ // Ignore timeouts and reissue the poll.
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) Poll timed out, reissuing.");
+ }
+ else {
+ // Close the connection with the error as the result.
+ this.closeError = e_1;
+ this.running = false;
+ }
+ }
+ return [3 /*break*/, 6];
+ case 6: return [3 /*break*/, 1];
+ case 7: return [3 /*break*/, 9];
+ case 8:
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) Polling complete.");
+ // We will reach here with pollAborted==false when the server returned a response causing the transport to stop.
+ // If pollAborted==true then client initiated the stop and the stop method will raise the close event after DELETE is sent.
+ if (!this.pollAborted) {
+ this.raiseOnClose();
+ }
+ return [7 /*endfinally*/];
+ case 9: return [2 /*return*/];
+ }
+ });
+ });
+ };
+ LongPollingTransport.prototype.send = function (data) {
+ return __awaiter(this, void 0, void 0, function () {
+ return __generator(this, function (_a) {
+ if (!this.running) {
+ return [2 /*return*/, Promise.reject(new Error("Cannot send until the transport is connected"))];
+ }
+ return [2 /*return*/, Object(_Utils__WEBPACK_IMPORTED_MODULE_4__["sendMessage"])(this.logger, "LongPolling", this.httpClient, this.url, this.accessTokenFactory, data, this.logMessageContent)];
+ });
+ });
+ };
+ LongPollingTransport.prototype.stop = function () {
+ return __awaiter(this, void 0, void 0, function () {
+ var deleteOptions, token;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) Stopping polling.");
+ // Tell receiving loop to stop, abort any current request, and then wait for it to finish
+ this.running = false;
+ this.pollAbort.abort();
+ _a.label = 1;
+ case 1:
+ _a.trys.push([1, , 5, 6]);
+ return [4 /*yield*/, this.receiving];
+ case 2:
+ _a.sent();
+ // Send DELETE to clean up long polling on the server
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) sending DELETE request to " + this.url + ".");
+ deleteOptions = {
+ headers: {},
+ };
+ return [4 /*yield*/, this.getAccessToken()];
+ case 3:
+ token = _a.sent();
+ this.updateHeaderToken(deleteOptions, token);
+ return [4 /*yield*/, this.httpClient.delete(this.url, deleteOptions)];
+ case 4:
+ _a.sent();
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) DELETE request sent.");
+ return [3 /*break*/, 6];
+ case 5:
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, "(LongPolling transport) Stop finished.");
+ // Raise close event here instead of in polling
+ // It needs to happen after the DELETE request is sent
+ this.raiseOnClose();
+ return [7 /*endfinally*/];
+ case 6: return [2 /*return*/];
+ }
+ });
+ });
+ };
+ LongPollingTransport.prototype.raiseOnClose = function () {
+ if (this.onclose) {
+ var logMessage = "(LongPolling transport) Firing onclose event.";
+ if (this.closeError) {
+ logMessage += " Error: " + this.closeError;
+ }
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Trace, logMessage);
+ this.onclose(this.closeError);
+ }
+ };
+ return LongPollingTransport;
+}());
+
+//# sourceMappingURL=LongPollingTransport.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/ServerSentEventsTransport.js":
+/*!*****************************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/ServerSentEventsTransport.js ***!
+ \*****************************************************************************/
+/*! exports provided: ServerSentEventsTransport */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ServerSentEventsTransport", function() { return ServerSentEventsTransport; });
+/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ILogger */ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js");
+/* harmony import */ var _ITransport__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ITransport */ "../node_modules/@aspnet/signalr/dist/esm/ITransport.js");
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Utils */ "../node_modules/@aspnet/signalr/dist/esm/Utils.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ 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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (undefined && undefined.__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 (_) 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 };
+ }
+};
+
+
+
+/** @private */
+var ServerSentEventsTransport = /** @class */ (function () {
+ function ServerSentEventsTransport(httpClient, accessTokenFactory, logger, logMessageContent, eventSourceConstructor) {
+ this.httpClient = httpClient;
+ this.accessTokenFactory = accessTokenFactory;
+ this.logger = logger;
+ this.logMessageContent = logMessageContent;
+ this.eventSourceConstructor = eventSourceConstructor;
+ this.onreceive = null;
+ this.onclose = null;
+ }
+ ServerSentEventsTransport.prototype.connect = function (url, transferFormat) {
+ return __awaiter(this, void 0, void 0, function () {
+ var token;
+ var _this = this;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ _Utils__WEBPACK_IMPORTED_MODULE_2__["Arg"].isRequired(url, "url");
+ _Utils__WEBPACK_IMPORTED_MODULE_2__["Arg"].isRequired(transferFormat, "transferFormat");
+ _Utils__WEBPACK_IMPORTED_MODULE_2__["Arg"].isIn(transferFormat, _ITransport__WEBPACK_IMPORTED_MODULE_1__["TransferFormat"], "transferFormat");
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Trace, "(SSE transport) Connecting.");
+ // set url before accessTokenFactory because this.url is only for send and we set the auth header instead of the query string for send
+ this.url = url;
+ if (!this.accessTokenFactory) return [3 /*break*/, 2];
+ return [4 /*yield*/, this.accessTokenFactory()];
+ case 1:
+ token = _a.sent();
+ if (token) {
+ url += (url.indexOf("?") < 0 ? "?" : "&") + ("access_token=" + encodeURIComponent(token));
+ }
+ _a.label = 2;
+ case 2: return [2 /*return*/, new Promise(function (resolve, reject) {
+ var opened = false;
+ if (transferFormat !== _ITransport__WEBPACK_IMPORTED_MODULE_1__["TransferFormat"].Text) {
+ reject(new Error("The Server-Sent Events transport only supports the 'Text' transfer format"));
+ return;
+ }
+ var eventSource;
+ if (typeof window !== "undefined") {
+ eventSource = new _this.eventSourceConstructor(url, { withCredentials: true });
+ }
+ else {
+ // Non-browser passes cookies via the dictionary
+ var cookies = _this.httpClient.getCookieString(url);
+ eventSource = new _this.eventSourceConstructor(url, { withCredentials: true, headers: { Cookie: cookies } });
+ }
+ try {
+ eventSource.onmessage = function (e) {
+ if (_this.onreceive) {
+ try {
+ _this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Trace, "(SSE transport) data received. " + Object(_Utils__WEBPACK_IMPORTED_MODULE_2__["getDataDetail"])(e.data, _this.logMessageContent) + ".");
+ _this.onreceive(e.data);
+ }
+ catch (error) {
+ _this.close(error);
+ return;
+ }
+ }
+ };
+ eventSource.onerror = function (e) {
+ var error = new Error(e.data || "Error occurred");
+ if (opened) {
+ _this.close(error);
+ }
+ else {
+ reject(error);
+ }
+ };
+ eventSource.onopen = function () {
+ _this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Information, "SSE connected to " + _this.url);
+ _this.eventSource = eventSource;
+ opened = true;
+ resolve();
+ };
+ }
+ catch (e) {
+ reject(e);
+ return;
+ }
+ })];
+ }
+ });
+ });
+ };
+ ServerSentEventsTransport.prototype.send = function (data) {
+ return __awaiter(this, void 0, void 0, function () {
+ return __generator(this, function (_a) {
+ if (!this.eventSource) {
+ return [2 /*return*/, Promise.reject(new Error("Cannot send until the transport is connected"))];
+ }
+ return [2 /*return*/, Object(_Utils__WEBPACK_IMPORTED_MODULE_2__["sendMessage"])(this.logger, "SSE", this.httpClient, this.url, this.accessTokenFactory, data, this.logMessageContent)];
+ });
+ });
+ };
+ ServerSentEventsTransport.prototype.stop = function () {
+ this.close();
+ return Promise.resolve();
+ };
+ ServerSentEventsTransport.prototype.close = function (e) {
+ if (this.eventSource) {
+ this.eventSource.close();
+ this.eventSource = undefined;
+ if (this.onclose) {
+ this.onclose(e);
+ }
+ }
+ };
+ return ServerSentEventsTransport;
+}());
+
+//# sourceMappingURL=ServerSentEventsTransport.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/TextMessageFormat.js":
+/*!*********************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/TextMessageFormat.js ***!
+ \*********************************************************************/
+/*! exports provided: TextMessageFormat */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextMessageFormat", function() { return TextMessageFormat; });
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+// Not exported from index
+/** @private */
+var TextMessageFormat = /** @class */ (function () {
+ function TextMessageFormat() {
+ }
+ TextMessageFormat.write = function (output) {
+ return "" + output + TextMessageFormat.RecordSeparator;
+ };
+ TextMessageFormat.parse = function (input) {
+ if (input[input.length - 1] !== TextMessageFormat.RecordSeparator) {
+ throw new Error("Message is incomplete.");
+ }
+ var messages = input.split(TextMessageFormat.RecordSeparator);
+ messages.pop();
+ return messages;
+ };
+ TextMessageFormat.RecordSeparatorCode = 0x1e;
+ TextMessageFormat.RecordSeparator = String.fromCharCode(TextMessageFormat.RecordSeparatorCode);
+ return TextMessageFormat;
+}());
+
+//# sourceMappingURL=TextMessageFormat.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/Utils.js":
+/*!*********************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/Utils.js ***!
+ \*********************************************************/
+/*! exports provided: Arg, getDataDetail, formatArrayBuffer, isArrayBuffer, sendMessage, createLogger, Subject, SubjectSubscription, ConsoleLogger */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Arg", function() { return Arg; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getDataDetail", function() { return getDataDetail; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "formatArrayBuffer", function() { return formatArrayBuffer; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isArrayBuffer", function() { return isArrayBuffer; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sendMessage", function() { return sendMessage; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createLogger", function() { return createLogger; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Subject", function() { return Subject; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SubjectSubscription", function() { return SubjectSubscription; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ConsoleLogger", function() { return ConsoleLogger; });
+/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ILogger */ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js");
+/* harmony import */ var _Loggers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Loggers */ "../node_modules/@aspnet/signalr/dist/esm/Loggers.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ 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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (undefined && undefined.__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 (_) 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 };
+ }
+};
+
+
+/** @private */
+var Arg = /** @class */ (function () {
+ function Arg() {
+ }
+ Arg.isRequired = function (val, name) {
+ if (val === null || val === undefined) {
+ throw new Error("The '" + name + "' argument is required.");
+ }
+ };
+ Arg.isIn = function (val, values, name) {
+ // TypeScript enums have keys for **both** the name and the value of each enum member on the type itself.
+ if (!(val in values)) {
+ throw new Error("Unknown " + name + " value: " + val + ".");
+ }
+ };
+ return Arg;
+}());
+
+/** @private */
+function getDataDetail(data, includeContent) {
+ var detail = "";
+ if (isArrayBuffer(data)) {
+ detail = "Binary data of length " + data.byteLength;
+ if (includeContent) {
+ detail += ". Content: '" + formatArrayBuffer(data) + "'";
+ }
+ }
+ else if (typeof data === "string") {
+ detail = "String data of length " + data.length;
+ if (includeContent) {
+ detail += ". Content: '" + data + "'";
+ }
+ }
+ return detail;
+}
+/** @private */
+function formatArrayBuffer(data) {
+ var view = new Uint8Array(data);
+ // Uint8Array.map only supports returning another Uint8Array?
+ var str = "";
+ view.forEach(function (num) {
+ var pad = num < 16 ? "0" : "";
+ str += "0x" + pad + num.toString(16) + " ";
+ });
+ // Trim of trailing space.
+ return str.substr(0, str.length - 1);
+}
+// Also in signalr-protocol-msgpack/Utils.ts
+/** @private */
+function isArrayBuffer(val) {
+ return val && typeof ArrayBuffer !== "undefined" &&
+ (val instanceof ArrayBuffer ||
+ // Sometimes we get an ArrayBuffer that doesn't satisfy instanceof
+ (val.constructor && val.constructor.name === "ArrayBuffer"));
+}
+/** @private */
+function sendMessage(logger, transportName, httpClient, url, accessTokenFactory, content, logMessageContent) {
+ return __awaiter(this, void 0, void 0, function () {
+ var _a, headers, token, responseType, response;
+ return __generator(this, function (_b) {
+ switch (_b.label) {
+ case 0:
+ if (!accessTokenFactory) return [3 /*break*/, 2];
+ return [4 /*yield*/, accessTokenFactory()];
+ case 1:
+ token = _b.sent();
+ if (token) {
+ headers = (_a = {},
+ _a["Authorization"] = "Bearer " + token,
+ _a);
+ }
+ _b.label = 2;
+ case 2:
+ logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Trace, "(" + transportName + " transport) sending data. " + getDataDetail(content, logMessageContent) + ".");
+ responseType = isArrayBuffer(content) ? "arraybuffer" : "text";
+ return [4 /*yield*/, httpClient.post(url, {
+ content: content,
+ headers: headers,
+ responseType: responseType,
+ })];
+ case 3:
+ response = _b.sent();
+ logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Trace, "(" + transportName + " transport) request complete. Response status: " + response.statusCode + ".");
+ return [2 /*return*/];
+ }
+ });
+ });
+}
+/** @private */
+function createLogger(logger) {
+ if (logger === undefined) {
+ return new ConsoleLogger(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Information);
+ }
+ if (logger === null) {
+ return _Loggers__WEBPACK_IMPORTED_MODULE_1__["NullLogger"].instance;
+ }
+ if (logger.log) {
+ return logger;
+ }
+ return new ConsoleLogger(logger);
+}
+/** @private */
+var Subject = /** @class */ (function () {
+ function Subject(cancelCallback) {
+ this.observers = [];
+ this.cancelCallback = cancelCallback;
+ }
+ Subject.prototype.next = function (item) {
+ for (var _i = 0, _a = this.observers; _i < _a.length; _i++) {
+ var observer = _a[_i];
+ observer.next(item);
+ }
+ };
+ Subject.prototype.error = function (err) {
+ for (var _i = 0, _a = this.observers; _i < _a.length; _i++) {
+ var observer = _a[_i];
+ if (observer.error) {
+ observer.error(err);
+ }
+ }
+ };
+ Subject.prototype.complete = function () {
+ for (var _i = 0, _a = this.observers; _i < _a.length; _i++) {
+ var observer = _a[_i];
+ if (observer.complete) {
+ observer.complete();
+ }
+ }
+ };
+ Subject.prototype.subscribe = function (observer) {
+ this.observers.push(observer);
+ return new SubjectSubscription(this, observer);
+ };
+ return Subject;
+}());
+
+/** @private */
+var SubjectSubscription = /** @class */ (function () {
+ function SubjectSubscription(subject, observer) {
+ this.subject = subject;
+ this.observer = observer;
+ }
+ SubjectSubscription.prototype.dispose = function () {
+ var index = this.subject.observers.indexOf(this.observer);
+ if (index > -1) {
+ this.subject.observers.splice(index, 1);
+ }
+ if (this.subject.observers.length === 0) {
+ this.subject.cancelCallback().catch(function (_) { });
+ }
+ };
+ return SubjectSubscription;
+}());
+
+/** @private */
+var ConsoleLogger = /** @class */ (function () {
+ function ConsoleLogger(minimumLogLevel) {
+ this.minimumLogLevel = minimumLogLevel;
+ }
+ ConsoleLogger.prototype.log = function (logLevel, message) {
+ if (logLevel >= this.minimumLogLevel) {
+ switch (logLevel) {
+ case _ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Critical:
+ case _ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Error:
+ console.error("[" + new Date().toISOString() + "] " + _ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"][logLevel] + ": " + message);
+ break;
+ case _ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Warning:
+ console.warn("[" + new Date().toISOString() + "] " + _ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"][logLevel] + ": " + message);
+ break;
+ case _ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Information:
+ console.info("[" + new Date().toISOString() + "] " + _ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"][logLevel] + ": " + message);
+ break;
+ default:
+ // console.debug only goes to attached debuggers in Node, so we use console.log for Trace and Debug
+ console.log("[" + new Date().toISOString() + "] " + _ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"][logLevel] + ": " + message);
+ break;
+ }
+ }
+ };
+ return ConsoleLogger;
+}());
+
+//# sourceMappingURL=Utils.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/WebSocketTransport.js":
+/*!**********************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/WebSocketTransport.js ***!
+ \**********************************************************************/
+/*! exports provided: WebSocketTransport */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "WebSocketTransport", function() { return WebSocketTransport; });
+/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ILogger */ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js");
+/* harmony import */ var _ITransport__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ITransport */ "../node_modules/@aspnet/signalr/dist/esm/ITransport.js");
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Utils */ "../node_modules/@aspnet/signalr/dist/esm/Utils.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ 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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (undefined && undefined.__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 (_) 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 };
+ }
+};
+
+
+
+/** @private */
+var WebSocketTransport = /** @class */ (function () {
+ function WebSocketTransport(httpClient, accessTokenFactory, logger, logMessageContent, webSocketConstructor) {
+ this.logger = logger;
+ this.accessTokenFactory = accessTokenFactory;
+ this.logMessageContent = logMessageContent;
+ this.webSocketConstructor = webSocketConstructor;
+ this.httpClient = httpClient;
+ this.onreceive = null;
+ this.onclose = null;
+ }
+ WebSocketTransport.prototype.connect = function (url, transferFormat) {
+ return __awaiter(this, void 0, void 0, function () {
+ var token;
+ var _this = this;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ _Utils__WEBPACK_IMPORTED_MODULE_2__["Arg"].isRequired(url, "url");
+ _Utils__WEBPACK_IMPORTED_MODULE_2__["Arg"].isRequired(transferFormat, "transferFormat");
+ _Utils__WEBPACK_IMPORTED_MODULE_2__["Arg"].isIn(transferFormat, _ITransport__WEBPACK_IMPORTED_MODULE_1__["TransferFormat"], "transferFormat");
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Trace, "(WebSockets transport) Connecting.");
+ if (!this.accessTokenFactory) return [3 /*break*/, 2];
+ return [4 /*yield*/, this.accessTokenFactory()];
+ case 1:
+ token = _a.sent();
+ if (token) {
+ url += (url.indexOf("?") < 0 ? "?" : "&") + ("access_token=" + encodeURIComponent(token));
+ }
+ _a.label = 2;
+ case 2: return [2 /*return*/, new Promise(function (resolve, reject) {
+ url = url.replace(/^http/, "ws");
+ var webSocket;
+ var cookies = _this.httpClient.getCookieString(url);
+ if (typeof window === "undefined" && cookies) {
+ // Only pass cookies when in non-browser environments
+ webSocket = new _this.webSocketConstructor(url, undefined, {
+ headers: {
+ Cookie: "" + cookies,
+ },
+ });
+ }
+ if (!webSocket) {
+ // Chrome is not happy with passing 'undefined' as protocol
+ webSocket = new _this.webSocketConstructor(url);
+ }
+ if (transferFormat === _ITransport__WEBPACK_IMPORTED_MODULE_1__["TransferFormat"].Binary) {
+ webSocket.binaryType = "arraybuffer";
+ }
+ // tslint:disable-next-line:variable-name
+ webSocket.onopen = function (_event) {
+ _this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Information, "WebSocket connected to " + url + ".");
+ _this.webSocket = webSocket;
+ resolve();
+ };
+ webSocket.onerror = function (event) {
+ var error = null;
+ // ErrorEvent is a browser only type we need to check if the type exists before using it
+ if (typeof ErrorEvent !== "undefined" && event instanceof ErrorEvent) {
+ error = event.error;
+ }
+ reject(error);
+ };
+ webSocket.onmessage = function (message) {
+ _this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Trace, "(WebSockets transport) data received. " + Object(_Utils__WEBPACK_IMPORTED_MODULE_2__["getDataDetail"])(message.data, _this.logMessageContent) + ".");
+ if (_this.onreceive) {
+ _this.onreceive(message.data);
+ }
+ };
+ webSocket.onclose = function (event) { return _this.close(event); };
+ })];
+ }
+ });
+ });
+ };
+ WebSocketTransport.prototype.send = function (data) {
+ if (this.webSocket && this.webSocket.readyState === this.webSocketConstructor.OPEN) {
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Trace, "(WebSockets transport) sending data. " + Object(_Utils__WEBPACK_IMPORTED_MODULE_2__["getDataDetail"])(data, this.logMessageContent) + ".");
+ this.webSocket.send(data);
+ return Promise.resolve();
+ }
+ return Promise.reject("WebSocket is not in the OPEN state");
+ };
+ WebSocketTransport.prototype.stop = function () {
+ if (this.webSocket) {
+ // Clear websocket handlers because we are considering the socket closed now
+ this.webSocket.onclose = function () { };
+ this.webSocket.onmessage = function () { };
+ this.webSocket.onerror = function () { };
+ this.webSocket.close();
+ this.webSocket = undefined;
+ // Manually invoke onclose callback inline so we know the HttpConnection was closed properly before returning
+ // This also solves an issue where websocket.onclose could take 18+ seconds to trigger during network disconnects
+ this.close(undefined);
+ }
+ return Promise.resolve();
+ };
+ WebSocketTransport.prototype.close = function (event) {
+ // webSocket will be null if the transport did not start successfully
+ this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_0__["LogLevel"].Trace, "(WebSockets transport) socket closed.");
+ if (this.onclose) {
+ if (event && (event.wasClean === false || event.code !== 1000)) {
+ this.onclose(new Error("WebSocket closed with status code: " + event.code + " (" + event.reason + ")."));
+ }
+ else {
+ this.onclose();
+ }
+ }
+ };
+ return WebSocketTransport;
+}());
+
+//# sourceMappingURL=WebSocketTransport.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/XhrHttpClient.js":
+/*!*****************************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/XhrHttpClient.js ***!
+ \*****************************************************************/
+/*! exports provided: XhrHttpClient */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "XhrHttpClient", function() { return XhrHttpClient; });
+/* harmony import */ var _Errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Errors */ "../node_modules/@aspnet/signalr/dist/esm/Errors.js");
+/* harmony import */ var _HttpClient__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./HttpClient */ "../node_modules/@aspnet/signalr/dist/esm/HttpClient.js");
+/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ILogger */ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js");
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+var __extends = (undefined && undefined.__extends) || (function () {
+ var extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+
+
+
+var XhrHttpClient = /** @class */ (function (_super) {
+ __extends(XhrHttpClient, _super);
+ function XhrHttpClient(logger) {
+ var _this = _super.call(this) || this;
+ _this.logger = logger;
+ return _this;
+ }
+ /** @inheritDoc */
+ XhrHttpClient.prototype.send = function (request) {
+ var _this = this;
+ // Check that abort was not signaled before calling send
+ if (request.abortSignal && request.abortSignal.aborted) {
+ return Promise.reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["AbortError"]());
+ }
+ if (!request.method) {
+ return Promise.reject(new Error("No method defined."));
+ }
+ if (!request.url) {
+ return Promise.reject(new Error("No url defined."));
+ }
+ return new Promise(function (resolve, reject) {
+ var xhr = new XMLHttpRequest();
+ xhr.open(request.method, request.url, true);
+ xhr.withCredentials = true;
+ xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+ // Explicitly setting the Content-Type header for React Native on Android platform.
+ xhr.setRequestHeader("Content-Type", "text/plain;charset=UTF-8");
+ var headers = request.headers;
+ if (headers) {
+ Object.keys(headers)
+ .forEach(function (header) {
+ xhr.setRequestHeader(header, headers[header]);
+ });
+ }
+ if (request.responseType) {
+ xhr.responseType = request.responseType;
+ }
+ if (request.abortSignal) {
+ request.abortSignal.onabort = function () {
+ xhr.abort();
+ reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["AbortError"]());
+ };
+ }
+ if (request.timeout) {
+ xhr.timeout = request.timeout;
+ }
+ xhr.onload = function () {
+ if (request.abortSignal) {
+ request.abortSignal.onabort = null;
+ }
+ if (xhr.status >= 200 && xhr.status < 300) {
+ resolve(new _HttpClient__WEBPACK_IMPORTED_MODULE_1__["HttpResponse"](xhr.status, xhr.statusText, xhr.response || xhr.responseText));
+ }
+ else {
+ reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["HttpError"](xhr.statusText, xhr.status));
+ }
+ };
+ xhr.onerror = function () {
+ _this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Warning, "Error from HTTP request. " + xhr.status + ": " + xhr.statusText + ".");
+ reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["HttpError"](xhr.statusText, xhr.status));
+ };
+ xhr.ontimeout = function () {
+ _this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Warning, "Timeout from HTTP request.");
+ reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["TimeoutError"]());
+ };
+ xhr.send(request.content || "");
+ });
+ };
+ return XhrHttpClient;
+}(_HttpClient__WEBPACK_IMPORTED_MODULE_1__["HttpClient"]));
+
+//# sourceMappingURL=XhrHttpClient.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@aspnet/signalr/dist/esm/index.js":
+/*!*********************************************************!*\
+ !*** ../node_modules/@aspnet/signalr/dist/esm/index.js ***!
+ \*********************************************************/
+/*! exports provided: VERSION, AbortError, HttpError, TimeoutError, HttpClient, HttpResponse, DefaultHttpClient, HubConnection, HubConnectionState, HubConnectionBuilder, MessageType, LogLevel, HttpTransportType, TransferFormat, NullLogger, JsonHubProtocol */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "VERSION", function() { return VERSION; });
+/* harmony import */ var _Errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Errors */ "../node_modules/@aspnet/signalr/dist/esm/Errors.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "AbortError", function() { return _Errors__WEBPACK_IMPORTED_MODULE_0__["AbortError"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpError", function() { return _Errors__WEBPACK_IMPORTED_MODULE_0__["HttpError"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimeoutError", function() { return _Errors__WEBPACK_IMPORTED_MODULE_0__["TimeoutError"]; });
+
+/* harmony import */ var _HttpClient__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./HttpClient */ "../node_modules/@aspnet/signalr/dist/esm/HttpClient.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpClient", function() { return _HttpClient__WEBPACK_IMPORTED_MODULE_1__["HttpClient"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpResponse", function() { return _HttpClient__WEBPACK_IMPORTED_MODULE_1__["HttpResponse"]; });
+
+/* harmony import */ var _DefaultHttpClient__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./DefaultHttpClient */ "../node_modules/@aspnet/signalr/dist/esm/DefaultHttpClient.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "DefaultHttpClient", function() { return _DefaultHttpClient__WEBPACK_IMPORTED_MODULE_2__["DefaultHttpClient"]; });
+
+/* harmony import */ var _HubConnection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./HubConnection */ "../node_modules/@aspnet/signalr/dist/esm/HubConnection.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HubConnection", function() { return _HubConnection__WEBPACK_IMPORTED_MODULE_3__["HubConnection"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HubConnectionState", function() { return _HubConnection__WEBPACK_IMPORTED_MODULE_3__["HubConnectionState"]; });
+
+/* harmony import */ var _HubConnectionBuilder__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./HubConnectionBuilder */ "../node_modules/@aspnet/signalr/dist/esm/HubConnectionBuilder.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HubConnectionBuilder", function() { return _HubConnectionBuilder__WEBPACK_IMPORTED_MODULE_4__["HubConnectionBuilder"]; });
+
+/* harmony import */ var _IHubProtocol__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./IHubProtocol */ "../node_modules/@aspnet/signalr/dist/esm/IHubProtocol.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "MessageType", function() { return _IHubProtocol__WEBPACK_IMPORTED_MODULE_5__["MessageType"]; });
+
+/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./ILogger */ "../node_modules/@aspnet/signalr/dist/esm/ILogger.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "LogLevel", function() { return _ILogger__WEBPACK_IMPORTED_MODULE_6__["LogLevel"]; });
+
+/* harmony import */ var _ITransport__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./ITransport */ "../node_modules/@aspnet/signalr/dist/esm/ITransport.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpTransportType", function() { return _ITransport__WEBPACK_IMPORTED_MODULE_7__["HttpTransportType"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TransferFormat", function() { return _ITransport__WEBPACK_IMPORTED_MODULE_7__["TransferFormat"]; });
+
+/* harmony import */ var _Loggers__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./Loggers */ "../node_modules/@aspnet/signalr/dist/esm/Loggers.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "NullLogger", function() { return _Loggers__WEBPACK_IMPORTED_MODULE_8__["NullLogger"]; });
+
+/* harmony import */ var _JsonHubProtocol__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./JsonHubProtocol */ "../node_modules/@aspnet/signalr/dist/esm/JsonHubProtocol.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "JsonHubProtocol", function() { return _JsonHubProtocol__WEBPACK_IMPORTED_MODULE_9__["JsonHubProtocol"]; });
+
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+// Version token that will be replaced by the prepack command
+/** The version of the SignalR client. */
+var VERSION = "1.1.2";
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "../node_modules/@dotnet/jsinterop/dist/Microsoft.JSInterop.js":
+/*!*********************************************************************!*\
+ !*** ../node_modules/@dotnet/jsinterop/dist/Microsoft.JSInterop.js ***!
+ \*********************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// This is a single-file self-contained module to avoid the need for a Webpack build
+var DotNet;
+(function (DotNet) {
+ window.DotNet = DotNet; // Ensure reachable from anywhere
+ var jsonRevivers = [];
+ var pendingAsyncCalls = {};
+ var cachedJSFunctions = {};
+ var nextAsyncCallId = 1; // Start at 1 because zero signals "no response needed"
+ var dotNetDispatcher = null;
+ /**
+ * Sets the specified .NET call dispatcher as the current instance so that it will be used
+ * for future invocations.
+ *
+ * @param dispatcher An object that can dispatch calls from JavaScript to a .NET runtime.
+ */
+ function attachDispatcher(dispatcher) {
+ dotNetDispatcher = dispatcher;
+ }
+ DotNet.attachDispatcher = attachDispatcher;
+ /**
+ * Adds a JSON reviver callback that will be used when parsing arguments received from .NET.
+ * @param reviver The reviver to add.
+ */
+ function attachReviver(reviver) {
+ jsonRevivers.push(reviver);
+ }
+ DotNet.attachReviver = attachReviver;
+ /**
+ * Invokes the specified .NET public method synchronously. Not all hosting scenarios support
+ * synchronous invocation, so if possible use invokeMethodAsync instead.
+ *
+ * @param assemblyName The short name (without key/version or .dll extension) of the .NET assembly containing the method.
+ * @param methodIdentifier The identifier of the method to invoke. The method must have a [JSInvokable] attribute specifying this identifier.
+ * @param args Arguments to pass to the method, each of which must be JSON-serializable.
+ * @returns The result of the operation.
+ */
+ function invokeMethod(assemblyName, methodIdentifier) {
+ var args = [];
+ for (var _i = 2; _i < arguments.length; _i++) {
+ args[_i - 2] = arguments[_i];
+ }
+ return invokePossibleInstanceMethod(assemblyName, methodIdentifier, null, args);
+ }
+ DotNet.invokeMethod = invokeMethod;
+ /**
+ * Invokes the specified .NET public method asynchronously.
+ *
+ * @param assemblyName The short name (without key/version or .dll extension) of the .NET assembly containing the method.
+ * @param methodIdentifier The identifier of the method to invoke. The method must have a [JSInvokable] attribute specifying this identifier.
+ * @param args Arguments to pass to the method, each of which must be JSON-serializable.
+ * @returns A promise representing the result of the operation.
+ */
+ function invokeMethodAsync(assemblyName, methodIdentifier) {
+ var args = [];
+ for (var _i = 2; _i < arguments.length; _i++) {
+ args[_i - 2] = arguments[_i];
+ }
+ return invokePossibleInstanceMethodAsync(assemblyName, methodIdentifier, null, args);
+ }
+ DotNet.invokeMethodAsync = invokeMethodAsync;
+ function invokePossibleInstanceMethod(assemblyName, methodIdentifier, dotNetObjectId, args) {
+ var dispatcher = getRequiredDispatcher();
+ if (dispatcher.invokeDotNetFromJS) {
+ var argsJson = JSON.stringify(args, argReplacer);
+ var resultJson = dispatcher.invokeDotNetFromJS(assemblyName, methodIdentifier, dotNetObjectId, argsJson);
+ return resultJson ? parseJsonWithRevivers(resultJson) : null;
+ }
+ else {
+ throw new Error('The current dispatcher does not support synchronous calls from JS to .NET. Use invokeMethodAsync instead.');
+ }
+ }
+ function invokePossibleInstanceMethodAsync(assemblyName, methodIdentifier, dotNetObjectId, args) {
+ var asyncCallId = nextAsyncCallId++;
+ var resultPromise = new Promise(function (resolve, reject) {
+ pendingAsyncCalls[asyncCallId] = { resolve: resolve, reject: reject };
+ });
+ try {
+ var argsJson = JSON.stringify(args, argReplacer);
+ getRequiredDispatcher().beginInvokeDotNetFromJS(asyncCallId, assemblyName, methodIdentifier, dotNetObjectId, argsJson);
+ }
+ catch (ex) {
+ // Synchronous failure
+ completePendingCall(asyncCallId, false, ex);
+ }
+ return resultPromise;
+ }
+ function getRequiredDispatcher() {
+ if (dotNetDispatcher !== null) {
+ return dotNetDispatcher;
+ }
+ throw new Error('No .NET call dispatcher has been set.');
+ }
+ function completePendingCall(asyncCallId, success, resultOrError) {
+ if (!pendingAsyncCalls.hasOwnProperty(asyncCallId)) {
+ throw new Error("There is no pending async call with ID " + asyncCallId + ".");
+ }
+ var asyncCall = pendingAsyncCalls[asyncCallId];
+ delete pendingAsyncCalls[asyncCallId];
+ if (success) {
+ asyncCall.resolve(resultOrError);
+ }
+ else {
+ asyncCall.reject(resultOrError);
+ }
+ }
+ /**
+ * Receives incoming calls from .NET and dispatches them to JavaScript.
+ */
+ DotNet.jsCallDispatcher = {
+ /**
+ * Finds the JavaScript function matching the specified identifier.
+ *
+ * @param identifier Identifies the globally-reachable function to be returned.
+ * @returns A Function instance.
+ */
+ findJSFunction: findJSFunction,
+ /**
+ * Invokes the specified synchronous JavaScript function.
+ *
+ * @param identifier Identifies the globally-reachable function to invoke.
+ * @param argsJson JSON representation of arguments to be passed to the function.
+ * @returns JSON representation of the invocation result.
+ */
+ invokeJSFromDotNet: function (identifier, argsJson) {
+ var result = findJSFunction(identifier).apply(null, parseJsonWithRevivers(argsJson));
+ return result === null || result === undefined
+ ? null
+ : JSON.stringify(result, argReplacer);
+ },
+ /**
+ * Invokes the specified synchronous or asynchronous JavaScript function.
+ *
+ * @param asyncHandle A value identifying the asynchronous operation. This value will be passed back in a later call to endInvokeJSFromDotNet.
+ * @param identifier Identifies the globally-reachable function to invoke.
+ * @param argsJson JSON representation of arguments to be passed to the function.
+ */
+ beginInvokeJSFromDotNet: function (asyncHandle, identifier, argsJson) {
+ // Coerce synchronous functions into async ones, plus treat
+ // synchronous exceptions the same as async ones
+ var promise = new Promise(function (resolve) {
+ var synchronousResultOrPromise = findJSFunction(identifier).apply(null, parseJsonWithRevivers(argsJson));
+ resolve(synchronousResultOrPromise);
+ });
+ // We only listen for a result if the caller wants to be notified about it
+ if (asyncHandle) {
+ // On completion, dispatch result back to .NET
+ // Not using "await" because it codegens a lot of boilerplate
+ promise.then(function (result) { return getRequiredDispatcher().beginInvokeDotNetFromJS(0, 'Microsoft.JSInterop', 'DotNetDispatcher.EndInvoke', null, JSON.stringify([asyncHandle, true, result], argReplacer)); }, function (error) { return getRequiredDispatcher().beginInvokeDotNetFromJS(0, 'Microsoft.JSInterop', 'DotNetDispatcher.EndInvoke', null, JSON.stringify([asyncHandle, false, formatError(error)])); });
+ }
+ },
+ /**
+ * Receives notification that an async call from JS to .NET has completed.
+ * @param asyncCallId The identifier supplied in an earlier call to beginInvokeDotNetFromJS.
+ * @param success A flag to indicate whether the operation completed successfully.
+ * @param resultOrExceptionMessage Either the operation result or an error message.
+ */
+ endInvokeDotNetFromJS: function (asyncCallId, success, resultOrExceptionMessage) {
+ var resultOrError = success ? resultOrExceptionMessage : new Error(resultOrExceptionMessage);
+ completePendingCall(parseInt(asyncCallId), success, resultOrError);
+ }
+ };
+ function parseJsonWithRevivers(json) {
+ return json ? JSON.parse(json, function (key, initialValue) {
+ // Invoke each reviver in order, passing the output from the previous reviver,
+ // so that each one gets a chance to transform the value
+ return jsonRevivers.reduce(function (latestValue, reviver) { return reviver(key, latestValue); }, initialValue);
+ }) : null;
+ }
+ function formatError(error) {
+ if (error instanceof Error) {
+ return error.message + "\n" + error.stack;
+ }
+ else {
+ return error ? error.toString() : 'null';
+ }
+ }
+ function findJSFunction(identifier) {
+ if (cachedJSFunctions.hasOwnProperty(identifier)) {
+ return cachedJSFunctions[identifier];
+ }
+ var result = window;
+ var resultIdentifier = 'window';
+ identifier.split('.').forEach(function (segment) {
+ if (segment in result) {
+ result = result[segment];
+ resultIdentifier += '.' + segment;
+ }
+ else {
+ throw new Error("Could not find '" + segment + "' in '" + resultIdentifier + "'.");
+ }
+ });
+ if (result instanceof Function) {
+ return result;
+ }
+ else {
+ throw new Error("The value '" + resultIdentifier + "' is not a function.");
+ }
+ }
+ var DotNetObject = /** @class */ (function () {
+ function DotNetObject(_id) {
+ this._id = _id;
+ }
+ DotNetObject.prototype.invokeMethod = function (methodIdentifier) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ return invokePossibleInstanceMethod(null, methodIdentifier, this._id, args);
+ };
+ DotNetObject.prototype.invokeMethodAsync = function (methodIdentifier) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ return invokePossibleInstanceMethodAsync(null, methodIdentifier, this._id, args);
+ };
+ DotNetObject.prototype.dispose = function () {
+ var promise = invokeMethodAsync('Microsoft.JSInterop', 'DotNetDispatcher.ReleaseDotNetObject', this._id);
+ promise.catch(function (error) { return console.error(error); });
+ };
+ DotNetObject.prototype.serializeAsArg = function () {
+ return "__dotNetObject:" + this._id;
+ };
+ return DotNetObject;
+ }());
+ var dotNetObjectValueFormat = /^__dotNetObject\:(\d+)$/;
+ attachReviver(function reviveDotNetObject(key, value) {
+ if (typeof value === 'string') {
+ var match = value.match(dotNetObjectValueFormat);
+ if (match) {
+ return new DotNetObject(parseInt(match[1]));
+ }
+ }
+ // Unrecognized - let another reviver handle it
+ return value;
+ });
+ function argReplacer(key, value) {
+ return value instanceof DotNetObject ? value.serializeAsArg() : value;
+ }
+})(DotNet || (DotNet = {}));
+//# sourceMappingURL=Microsoft.JSInterop.js.map
+
+/***/ }),
+
+/***/ "../node_modules/assert/assert.js":
+/*!****************************************!*\
+ !*** ../node_modules/assert/assert.js ***!
+ \****************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+
+// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
+// original notice:
+
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh
+ * @license MIT
+ */
+function compare(a, b) {
+ if (a === b) {
+ return 0;
+ }
+
+ var x = a.length;
+ var y = b.length;
+
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i];
+ y = b[i];
+ break;
+ }
+ }
+
+ if (x < y) {
+ return -1;
+ }
+ if (y < x) {
+ return 1;
+ }
+ return 0;
+}
+function isBuffer(b) {
+ if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {
+ return global.Buffer.isBuffer(b);
+ }
+ return !!(b != null && b._isBuffer);
+}
+
+// based on node assert, original notice:
+
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// 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 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.
+
+var util = __webpack_require__(/*! util/ */ "../node_modules/util/util.js");
+var hasOwn = Object.prototype.hasOwnProperty;
+var pSlice = Array.prototype.slice;
+var functionsHaveNames = (function () {
+ return function foo() {}.name === 'foo';
+}());
+function pToString (obj) {
+ return Object.prototype.toString.call(obj);
+}
+function isView(arrbuf) {
+ if (isBuffer(arrbuf)) {
+ return false;
+ }
+ if (typeof global.ArrayBuffer !== 'function') {
+ return false;
+ }
+ if (typeof ArrayBuffer.isView === 'function') {
+ return ArrayBuffer.isView(arrbuf);
+ }
+ if (!arrbuf) {
+ return false;
+ }
+ if (arrbuf instanceof DataView) {
+ return true;
+ }
+ if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
+ return true;
+ }
+ return false;
+}
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
+var assert = module.exports = ok;
+
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({ message: message,
+// actual: actual,
+// expected: expected })
+
+var regex = /\s*function\s+([^\(\s]*)\s*/;
+// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js
+function getName(func) {
+ if (!util.isFunction(func)) {
+ return;
+ }
+ if (functionsHaveNames) {
+ return func.name;
+ }
+ var str = func.toString();
+ var match = str.match(regex);
+ return match && match[1];
+}
+assert.AssertionError = function AssertionError(options) {
+ this.name = 'AssertionError';
+ this.actual = options.actual;
+ this.expected = options.expected;
+ this.operator = options.operator;
+ if (options.message) {
+ this.message = options.message;
+ this.generatedMessage = false;
+ } else {
+ this.message = getMessage(this);
+ this.generatedMessage = true;
+ }
+ var stackStartFunction = options.stackStartFunction || fail;
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, stackStartFunction);
+ } else {
+ // non v8 browsers so we can have a stacktrace
+ var err = new Error();
+ if (err.stack) {
+ var out = err.stack;
+
+ // try to strip useless frames
+ var fn_name = getName(stackStartFunction);
+ var idx = out.indexOf('\n' + fn_name);
+ if (idx >= 0) {
+ // once we have located the function frame
+ // we need to strip out everything before it (and its line)
+ var next_line = out.indexOf('\n', idx + 1);
+ out = out.substring(next_line + 1);
+ }
+
+ this.stack = out;
+ }
+ }
+};
+
+// assert.AssertionError instanceof Error
+util.inherits(assert.AssertionError, Error);
+
+function truncate(s, n) {
+ if (typeof s === 'string') {
+ return s.length < n ? s : s.slice(0, n);
+ } else {
+ return s;
+ }
+}
+function inspect(something) {
+ if (functionsHaveNames || !util.isFunction(something)) {
+ return util.inspect(something);
+ }
+ var rawname = getName(something);
+ var name = rawname ? ': ' + rawname : '';
+ return '[Function' + name + ']';
+}
+function getMessage(self) {
+ return truncate(inspect(self.actual), 128) + ' ' +
+ self.operator + ' ' +
+ truncate(inspect(self.expected), 128);
+}
+
+// At present only the three keys mentioned above are used and
+// understood by the spec. Implementations or sub modules can pass
+// other keys to the AssertionError's constructor - they will be
+// ignored.
+
+// 3. All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided. All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
+
+function fail(actual, expected, message, operator, stackStartFunction) {
+ throw new assert.AssertionError({
+ message: message,
+ actual: actual,
+ expected: expected,
+ operator: operator,
+ stackStartFunction: stackStartFunction
+ });
+}
+
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
+
+// 4. Pure assertion tests whether a value is truthy, as determined
+// by !!guard.
+// assert.ok(guard, message_opt);
+// This statement is equivalent to assert.equal(true, !!guard,
+// message_opt);. To test strictly for the value true, use
+// assert.strictEqual(true, guard, message_opt);.
+
+function ok(value, message) {
+ if (!value) fail(value, true, message, '==', assert.ok);
+}
+assert.ok = ok;
+
+// 5. The equality assertion tests shallow, coercive equality with
+// ==.
+// assert.equal(actual, expected, message_opt);
+
+assert.equal = function equal(actual, expected, message) {
+ if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+};
+
+// 6. The non-equality assertion tests for whether two objects are not equal
+// with != assert.notEqual(actual, expected, message_opt);
+
+assert.notEqual = function notEqual(actual, expected, message) {
+ if (actual == expected) {
+ fail(actual, expected, message, '!=', assert.notEqual);
+ }
+};
+
+// 7. The equivalence assertion tests a deep equality relation.
+// assert.deepEqual(actual, expected, message_opt);
+
+assert.deepEqual = function deepEqual(actual, expected, message) {
+ if (!_deepEqual(actual, expected, false)) {
+ fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+ }
+};
+
+assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+ if (!_deepEqual(actual, expected, true)) {
+ fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
+ }
+};
+
+function _deepEqual(actual, expected, strict, memos) {
+ // 7.1. All identical values are equivalent, as determined by ===.
+ if (actual === expected) {
+ return true;
+ } else if (isBuffer(actual) && isBuffer(expected)) {
+ return compare(actual, expected) === 0;
+
+ // 7.2. If the expected value is a Date object, the actual value is
+ // equivalent if it is also a Date object that refers to the same time.
+ } else if (util.isDate(actual) && util.isDate(expected)) {
+ return actual.getTime() === expected.getTime();
+
+ // 7.3 If the expected value is a RegExp object, the actual value is
+ // equivalent if it is also a RegExp object with the same source and
+ // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+ } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+ return actual.source === expected.source &&
+ actual.global === expected.global &&
+ actual.multiline === expected.multiline &&
+ actual.lastIndex === expected.lastIndex &&
+ actual.ignoreCase === expected.ignoreCase;
+
+ // 7.4. Other pairs that do not both pass typeof value == 'object',
+ // equivalence is determined by ==.
+ } else if ((actual === null || typeof actual !== 'object') &&
+ (expected === null || typeof expected !== 'object')) {
+ return strict ? actual === expected : actual == expected;
+
+ // If both values are instances of typed arrays, wrap their underlying
+ // ArrayBuffers in a Buffer each to increase performance
+ // This optimization requires the arrays to have the same type as checked by
+ // Object.prototype.toString (aka pToString). Never perform binary
+ // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
+ // bit patterns are not identical.
+ } else if (isView(actual) && isView(expected) &&
+ pToString(actual) === pToString(expected) &&
+ !(actual instanceof Float32Array ||
+ actual instanceof Float64Array)) {
+ return compare(new Uint8Array(actual.buffer),
+ new Uint8Array(expected.buffer)) === 0;
+
+ // 7.5 For all other Object pairs, including Array objects, equivalence is
+ // determined by having the same number of owned properties (as verified
+ // with Object.prototype.hasOwnProperty.call), the same set of keys
+ // (although not necessarily the same order), equivalent values for every
+ // corresponding key, and an identical 'prototype' property. Note: this
+ // accounts for both named and indexed properties on Arrays.
+ } else if (isBuffer(actual) !== isBuffer(expected)) {
+ return false;
+ } else {
+ memos = memos || {actual: [], expected: []};
+
+ var actualIndex = memos.actual.indexOf(actual);
+ if (actualIndex !== -1) {
+ if (actualIndex === memos.expected.indexOf(expected)) {
+ return true;
+ }
+ }
+
+ memos.actual.push(actual);
+ memos.expected.push(expected);
+
+ return objEquiv(actual, expected, strict, memos);
+ }
+}
+
+function isArguments(object) {
+ return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv(a, b, strict, actualVisitedObjects) {
+ if (a === null || a === undefined || b === null || b === undefined)
+ return false;
+ // if one is a primitive, the other must be same
+ if (util.isPrimitive(a) || util.isPrimitive(b))
+ return a === b;
+ if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
+ return false;
+ var aIsArgs = isArguments(a);
+ var bIsArgs = isArguments(b);
+ if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
+ return false;
+ if (aIsArgs) {
+ a = pSlice.call(a);
+ b = pSlice.call(b);
+ return _deepEqual(a, b, strict);
+ }
+ var ka = objectKeys(a);
+ var kb = objectKeys(b);
+ var key, i;
+ // having the same number of owned properties (keys incorporates
+ // hasOwnProperty)
+ if (ka.length !== kb.length)
+ return false;
+ //the same set of keys (although not necessarily the same order),
+ ka.sort();
+ kb.sort();
+ //~~~cheap key test
+ for (i = ka.length - 1; i >= 0; i--) {
+ if (ka[i] !== kb[i])
+ return false;
+ }
+ //equivalent values for every corresponding key, and
+ //~~~possibly expensive deep test
+ for (i = ka.length - 1; i >= 0; i--) {
+ key = ka[i];
+ if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
+ return false;
+ }
+ return true;
+}
+
+// 8. The non-equivalence assertion tests for any deep inequality.
+// assert.notDeepEqual(actual, expected, message_opt);
+
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+ if (_deepEqual(actual, expected, false)) {
+ fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+ }
+};
+
+assert.notDeepStrictEqual = notDeepStrictEqual;
+function notDeepStrictEqual(actual, expected, message) {
+ if (_deepEqual(actual, expected, true)) {
+ fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
+ }
+}
+
+
+// 9. The strict equality assertion tests strict equality, as determined by ===.
+// assert.strictEqual(actual, expected, message_opt);
+
+assert.strictEqual = function strictEqual(actual, expected, message) {
+ if (actual !== expected) {
+ fail(actual, expected, message, '===', assert.strictEqual);
+ }
+};
+
+// 10. The strict non-equality assertion tests for strict inequality, as
+// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
+
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+ if (actual === expected) {
+ fail(actual, expected, message, '!==', assert.notStrictEqual);
+ }
+};
+
+function expectedException(actual, expected) {
+ if (!actual || !expected) {
+ return false;
+ }
+
+ if (Object.prototype.toString.call(expected) == '[object RegExp]') {
+ return expected.test(actual);
+ }
+
+ try {
+ if (actual instanceof expected) {
+ return true;
+ }
+ } catch (e) {
+ // Ignore. The instanceof check doesn't work for arrow functions.
+ }
+
+ if (Error.isPrototypeOf(expected)) {
+ return false;
+ }
+
+ return expected.call({}, actual) === true;
+}
+
+function _tryBlock(block) {
+ var error;
+ try {
+ block();
+ } catch (e) {
+ error = e;
+ }
+ return error;
+}
+
+function _throws(shouldThrow, block, expected, message) {
+ var actual;
+
+ if (typeof block !== 'function') {
+ throw new TypeError('"block" argument must be a function');
+ }
+
+ if (typeof expected === 'string') {
+ message = expected;
+ expected = null;
+ }
+
+ actual = _tryBlock(block);
+
+ message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+ (message ? ' ' + message : '.');
+
+ if (shouldThrow && !actual) {
+ fail(actual, expected, 'Missing expected exception' + message);
+ }
+
+ var userProvidedMessage = typeof message === 'string';
+ var isUnwantedException = !shouldThrow && util.isError(actual);
+ var isUnexpectedException = !shouldThrow && actual && !expected;
+
+ if ((isUnwantedException &&
+ userProvidedMessage &&
+ expectedException(actual, expected)) ||
+ isUnexpectedException) {
+ fail(actual, expected, 'Got unwanted exception' + message);
+ }
+
+ if ((shouldThrow && actual && expected &&
+ !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+ throw actual;
+ }
+}
+
+// 11. Expected to throw an error:
+// assert.throws(block, Error_opt, message_opt);
+
+assert.throws = function(block, /*optional*/error, /*optional*/message) {
+ _throws(true, block, error, message);
+};
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
+ _throws(false, block, error, message);
+};
+
+assert.ifError = function(err) { if (err) throw err; };
+
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) {
+ if (hasOwn.call(obj, key)) keys.push(key);
+ }
+ return keys;
+};
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "../node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
+/***/ "../node_modules/base64-js/index.js":
+/*!******************************************!*\
+ !*** ../node_modules/base64-js/index.js ***!
+ \******************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.byteLength = byteLength
+exports.toByteArray = toByteArray
+exports.fromByteArray = fromByteArray
+
+var lookup = []
+var revLookup = []
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (var i = 0, len = code.length; i < len; ++i) {
+ lookup[i] = code[i]
+ revLookup[code.charCodeAt(i)] = i
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+function getLens (b64) {
+ var len = b64.length
+
+ if (len % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
+ }
+
+ // Trim off extra bytes after placeholder bytes are found
+ // See: https://github.com/beatgammit/base64-js/issues/42
+ var validLen = b64.indexOf('=')
+ if (validLen === -1) validLen = len
+
+ var placeHoldersLen = validLen === len
+ ? 0
+ : 4 - (validLen % 4)
+
+ return [validLen, placeHoldersLen]
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength (b64) {
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function _byteLength (b64, validLen, placeHoldersLen) {
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function toByteArray (b64) {
+ var tmp
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+
+ var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+ var curByte = 0
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ var len = placeHoldersLen > 0
+ ? validLen - 4
+ : validLen
+
+ for (var i = 0; i < len; i += 4) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 18) |
+ (revLookup[b64.charCodeAt(i + 1)] << 12) |
+ (revLookup[b64.charCodeAt(i + 2)] << 6) |
+ revLookup[b64.charCodeAt(i + 3)]
+ arr[curByte++] = (tmp >> 16) & 0xFF
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 2) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 2) |
+ (revLookup[b64.charCodeAt(i + 1)] >> 4)
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 1) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 10) |
+ (revLookup[b64.charCodeAt(i + 1)] << 4) |
+ (revLookup[b64.charCodeAt(i + 2)] >> 2)
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ return arr
+}
+
+function tripletToBase64 (num) {
+ return lookup[num >> 18 & 0x3F] +
+ lookup[num >> 12 & 0x3F] +
+ lookup[num >> 6 & 0x3F] +
+ lookup[num & 0x3F]
+}
+
+function encodeChunk (uint8, start, end) {
+ var tmp
+ var output = []
+ for (var i = start; i < end; i += 3) {
+ tmp =
+ ((uint8[i] << 16) & 0xFF0000) +
+ ((uint8[i + 1] << 8) & 0xFF00) +
+ (uint8[i + 2] & 0xFF)
+ output.push(tripletToBase64(tmp))
+ }
+ return output.join('')
+}
+
+function fromByteArray (uint8) {
+ var tmp
+ var len = uint8.length
+ var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+ var parts = []
+ var maxChunkLength = 16383 // must be multiple of 3
+
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+ parts.push(encodeChunk(
+ uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
+ ))
+ }
+
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ if (extraBytes === 1) {
+ tmp = uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 2] +
+ lookup[(tmp << 4) & 0x3F] +
+ '=='
+ )
+ } else if (extraBytes === 2) {
+ tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 10] +
+ lookup[(tmp >> 4) & 0x3F] +
+ lookup[(tmp << 2) & 0x3F] +
+ '='
+ )
+ }
+
+ return parts.join('')
+}
+
+
+/***/ }),
+
+/***/ "../node_modules/bl/bl.js":
+/*!********************************!*\
+ !*** ../node_modules/bl/bl.js ***!
+ \********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var DuplexStream = __webpack_require__(/*! readable-stream */ "../node_modules/readable-stream/readable-browser.js").Duplex
+ , util = __webpack_require__(/*! util */ "../node_modules/util/util.js")
+ , Buffer = __webpack_require__(/*! safe-buffer */ "../node_modules/safe-buffer/index.js").Buffer
+
+function BufferList (callback) {
+ if (!(this instanceof BufferList))
+ return new BufferList(callback)
+
+ this._bufs = []
+ this.length = 0
+
+ if (typeof callback == 'function') {
+ this._callback = callback
+
+ var piper = function piper (err) {
+ if (this._callback) {
+ this._callback(err)
+ this._callback = null
+ }
+ }.bind(this)
+
+ this.on('pipe', function onPipe (src) {
+ src.on('error', piper)
+ })
+ this.on('unpipe', function onUnpipe (src) {
+ src.removeListener('error', piper)
+ })
+ } else {
+ this.append(callback)
+ }
+
+ DuplexStream.call(this)
+}
+
+
+util.inherits(BufferList, DuplexStream)
+
+
+BufferList.prototype._offset = function _offset (offset) {
+ var tot = 0, i = 0, _t
+ if (offset === 0) return [ 0, 0 ]
+ for (; i < this._bufs.length; i++) {
+ _t = tot + this._bufs[i].length
+ if (offset < _t || i == this._bufs.length - 1) {
+ return [ i, offset - tot ]
+ }
+ tot = _t
+ }
+}
+
+BufferList.prototype._reverseOffset = function (blOffset) {
+ var bufferId = blOffset[0]
+ var offset = blOffset[1]
+ for (var i = 0; i < bufferId; i++) {
+ offset += this._bufs[i].length
+ }
+ return offset
+}
+
+BufferList.prototype.append = function append (buf) {
+ var i = 0
+
+ if (Buffer.isBuffer(buf)) {
+ this._appendBuffer(buf)
+ } else if (Array.isArray(buf)) {
+ for (; i < buf.length; i++)
+ this.append(buf[i])
+ } else if (buf instanceof BufferList) {
+ // unwrap argument into individual BufferLists
+ for (; i < buf._bufs.length; i++)
+ this.append(buf._bufs[i])
+ } else if (buf != null) {
+ // coerce number arguments to strings, since Buffer(number) does
+ // uninitialized memory allocation
+ if (typeof buf == 'number')
+ buf = buf.toString()
+
+ this._appendBuffer(Buffer.from(buf))
+ }
+
+ return this
+}
+
+
+BufferList.prototype._appendBuffer = function appendBuffer (buf) {
+ this._bufs.push(buf)
+ this.length += buf.length
+}
+
+
+BufferList.prototype._write = function _write (buf, encoding, callback) {
+ this._appendBuffer(buf)
+
+ if (typeof callback == 'function')
+ callback()
+}
+
+
+BufferList.prototype._read = function _read (size) {
+ if (!this.length)
+ return this.push(null)
+
+ size = Math.min(size, this.length)
+ this.push(this.slice(0, size))
+ this.consume(size)
+}
+
+
+BufferList.prototype.end = function end (chunk) {
+ DuplexStream.prototype.end.call(this, chunk)
+
+ if (this._callback) {
+ this._callback(null, this.slice())
+ this._callback = null
+ }
+}
+
+
+BufferList.prototype.get = function get (index) {
+ if (index > this.length || index < 0) {
+ return undefined
+ }
+ var offset = this._offset(index)
+ return this._bufs[offset[0]][offset[1]]
+}
+
+
+BufferList.prototype.slice = function slice (start, end) {
+ if (typeof start == 'number' && start < 0)
+ start += this.length
+ if (typeof end == 'number' && end < 0)
+ end += this.length
+ return this.copy(null, 0, start, end)
+}
+
+
+BufferList.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {
+ if (typeof srcStart != 'number' || srcStart < 0)
+ srcStart = 0
+ if (typeof srcEnd != 'number' || srcEnd > this.length)
+ srcEnd = this.length
+ if (srcStart >= this.length)
+ return dst || Buffer.alloc(0)
+ if (srcEnd <= 0)
+ return dst || Buffer.alloc(0)
+
+ var copy = !!dst
+ , off = this._offset(srcStart)
+ , len = srcEnd - srcStart
+ , bytes = len
+ , bufoff = (copy && dstStart) || 0
+ , start = off[1]
+ , l
+ , i
+
+ // copy/slice everything
+ if (srcStart === 0 && srcEnd == this.length) {
+ if (!copy) { // slice, but full concat if multiple buffers
+ return this._bufs.length === 1
+ ? this._bufs[0]
+ : Buffer.concat(this._bufs, this.length)
+ }
+
+ // copy, need to copy individual buffers
+ for (i = 0; i < this._bufs.length; i++) {
+ this._bufs[i].copy(dst, bufoff)
+ bufoff += this._bufs[i].length
+ }
+
+ return dst
+ }
+
+ // easy, cheap case where it's a subset of one of the buffers
+ if (bytes <= this._bufs[off[0]].length - start) {
+ return copy
+ ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
+ : this._bufs[off[0]].slice(start, start + bytes)
+ }
+
+ if (!copy) // a slice, we need something to copy in to
+ dst = Buffer.allocUnsafe(len)
+
+ for (i = off[0]; i < this._bufs.length; i++) {
+ l = this._bufs[i].length - start
+
+ if (bytes > l) {
+ this._bufs[i].copy(dst, bufoff, start)
+ } else {
+ this._bufs[i].copy(dst, bufoff, start, start + bytes)
+ break
+ }
+
+ bufoff += l
+ bytes -= l
+
+ if (start)
+ start = 0
+ }
+
+ return dst
+}
+
+BufferList.prototype.shallowSlice = function shallowSlice (start, end) {
+ start = start || 0
+ end = typeof end !== 'number' ? this.length : end
+
+ if (start < 0)
+ start += this.length
+ if (end < 0)
+ end += this.length
+
+ if (start === end) {
+ return new BufferList()
+ }
+ var startOffset = this._offset(start)
+ , endOffset = this._offset(end)
+ , buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)
+
+ if (endOffset[1] == 0)
+ buffers.pop()
+ else
+ buffers[buffers.length-1] = buffers[buffers.length-1].slice(0, endOffset[1])
+
+ if (startOffset[1] != 0)
+ buffers[0] = buffers[0].slice(startOffset[1])
+
+ return new BufferList(buffers)
+}
+
+BufferList.prototype.toString = function toString (encoding, start, end) {
+ return this.slice(start, end).toString(encoding)
+}
+
+BufferList.prototype.consume = function consume (bytes) {
+ while (this._bufs.length) {
+ if (bytes >= this._bufs[0].length) {
+ bytes -= this._bufs[0].length
+ this.length -= this._bufs[0].length
+ this._bufs.shift()
+ } else {
+ this._bufs[0] = this._bufs[0].slice(bytes)
+ this.length -= bytes
+ break
+ }
+ }
+ return this
+}
+
+
+BufferList.prototype.duplicate = function duplicate () {
+ var i = 0
+ , copy = new BufferList()
+
+ for (; i < this._bufs.length; i++)
+ copy.append(this._bufs[i])
+
+ return copy
+}
+
+
+BufferList.prototype.destroy = function destroy () {
+ this._bufs.length = 0
+ this.length = 0
+ this.push(null)
+}
+
+
+BufferList.prototype.indexOf = function (search, offset, encoding) {
+ if (encoding === undefined && typeof offset === 'string') {
+ encoding = offset
+ offset = undefined
+ }
+ if (typeof search === 'function' || Array.isArray(search)) {
+ throw new TypeError('The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.')
+ } else if (typeof search === 'number') {
+ search = Buffer.from([search])
+ } else if (typeof search === 'string') {
+ search = Buffer.from(search, encoding)
+ } else if (search instanceof BufferList) {
+ search = search.slice()
+ } else if (!Buffer.isBuffer(search)) {
+ search = Buffer.from(search)
+ }
+
+ offset = Number(offset || 0)
+ if (isNaN(offset)) {
+ offset = 0
+ }
+
+ if (offset < 0) {
+ offset = this.length + offset
+ }
+
+ if (offset < 0) {
+ offset = 0
+ }
+
+ if (search.length === 0) {
+ return offset > this.length ? this.length : offset
+ }
+
+ var blOffset = this._offset(offset)
+ var blIndex = blOffset[0] // index of which internal buffer we're working on
+ var buffOffset = blOffset[1] // offset of the internal buffer we're working on
+
+ // scan over each buffer
+ for (blIndex; blIndex < this._bufs.length; blIndex++) {
+ var buff = this._bufs[blIndex]
+ while(buffOffset < buff.length) {
+ var availableWindow = buff.length - buffOffset
+ if (availableWindow >= search.length) {
+ var nativeSearchResult = buff.indexOf(search, buffOffset)
+ if (nativeSearchResult !== -1) {
+ return this._reverseOffset([blIndex, nativeSearchResult])
+ }
+ buffOffset = buff.length - search.length + 1 // end of native search window
+ } else {
+ var revOffset = this._reverseOffset([blIndex, buffOffset])
+ if (this._match(revOffset, search)) {
+ return revOffset
+ }
+ buffOffset++
+ }
+ }
+ buffOffset = 0
+ }
+ return -1
+}
+
+BufferList.prototype._match = function(offset, search) {
+ if (this.length - offset < search.length) {
+ return false
+ }
+ for (var searchOffset = 0; searchOffset < search.length ; searchOffset++) {
+ if(this.get(offset + searchOffset) !== search[searchOffset]){
+ return false
+ }
+ }
+ return true
+}
+
+
+;(function () {
+ var methods = {
+ 'readDoubleBE' : 8
+ , 'readDoubleLE' : 8
+ , 'readFloatBE' : 4
+ , 'readFloatLE' : 4
+ , 'readInt32BE' : 4
+ , 'readInt32LE' : 4
+ , 'readUInt32BE' : 4
+ , 'readUInt32LE' : 4
+ , 'readInt16BE' : 2
+ , 'readInt16LE' : 2
+ , 'readUInt16BE' : 2
+ , 'readUInt16LE' : 2
+ , 'readInt8' : 1
+ , 'readUInt8' : 1
+ , 'readIntBE' : null
+ , 'readIntLE' : null
+ , 'readUIntBE' : null
+ , 'readUIntLE' : null
+ }
+
+ for (var m in methods) {
+ (function (m) {
+ if (methods[m] === null) {
+ BufferList.prototype[m] = function (offset, byteLength) {
+ return this.slice(offset, offset + byteLength)[m](0, byteLength)
+ }
+ }
+ else {
+ BufferList.prototype[m] = function (offset) {
+ return this.slice(offset, offset + methods[m])[m](0)
+ }
+ }
+ }(m))
+ }
+}())
+
+
+module.exports = BufferList
+
+
+/***/ }),
+
+/***/ "../node_modules/buffer/index.js":
+/*!***************************************!*\
+ !*** ../node_modules/buffer/index.js ***!
+ \***************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh
+ * @license MIT
+ */
+/* eslint-disable no-proto */
+
+
+
+var base64 = __webpack_require__(/*! base64-js */ "../node_modules/base64-js/index.js")
+var ieee754 = __webpack_require__(/*! ieee754 */ "../node_modules/ieee754/index.js")
+var isArray = __webpack_require__(/*! isarray */ "../node_modules/isarray/index.js")
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Use Object implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * Due to various browser bugs, sometimes the Object implementation will be used even
+ * when the browser supports typed arrays.
+ *
+ * Note:
+ *
+ * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
+ * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
+ *
+ * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
+ *
+ * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
+ * incorrect length in some situations.
+
+ * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
+ * get the Object implementation, which is slower but behaves correctly.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
+ ? global.TYPED_ARRAY_SUPPORT
+ : typedArraySupport()
+
+/*
+ * Export kMaxLength after typed array support is determined.
+ */
+exports.kMaxLength = kMaxLength()
+
+function typedArraySupport () {
+ try {
+ var arr = new Uint8Array(1)
+ arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
+ return arr.foo() === 42 && // typed array instances can be augmented
+ typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
+ arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
+ } catch (e) {
+ return false
+ }
+}
+
+function kMaxLength () {
+ return Buffer.TYPED_ARRAY_SUPPORT
+ ? 0x7fffffff
+ : 0x3fffffff
+}
+
+function createBuffer (that, length) {
+ if (kMaxLength() < length) {
+ throw new RangeError('Invalid typed array length')
+ }
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ // Return an augmented `Uint8Array` instance, for best performance
+ that = new Uint8Array(length)
+ that.__proto__ = Buffer.prototype
+ } else {
+ // Fallback: Return an object instance of the Buffer class
+ if (that === null) {
+ that = new Buffer(length)
+ }
+ that.length = length
+ }
+
+ return that
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer (arg, encodingOrOffset, length) {
+ if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
+ return new Buffer(arg, encodingOrOffset, length)
+ }
+
+ // Common case.
+ if (typeof arg === 'number') {
+ if (typeof encodingOrOffset === 'string') {
+ throw new Error(
+ 'If encoding is specified then the first argument must be a string'
+ )
+ }
+ return allocUnsafe(this, arg)
+ }
+ return from(this, arg, encodingOrOffset, length)
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+// TODO: Legacy, not needed anymore. Remove in next major version.
+Buffer._augment = function (arr) {
+ arr.__proto__ = Buffer.prototype
+ return arr
+}
+
+function from (that, value, encodingOrOffset, length) {
+ if (typeof value === 'number') {
+ throw new TypeError('"value" argument must not be a number')
+ }
+
+ if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+ return fromArrayBuffer(that, value, encodingOrOffset, length)
+ }
+
+ if (typeof value === 'string') {
+ return fromString(that, value, encodingOrOffset)
+ }
+
+ return fromObject(that, value)
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+ return from(null, value, encodingOrOffset, length)
+}
+
+if (Buffer.TYPED_ARRAY_SUPPORT) {
+ Buffer.prototype.__proto__ = Uint8Array.prototype
+ Buffer.__proto__ = Uint8Array
+ if (typeof Symbol !== 'undefined' && Symbol.species &&
+ Buffer[Symbol.species] === Buffer) {
+ // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+ Object.defineProperty(Buffer, Symbol.species, {
+ value: null,
+ configurable: true
+ })
+ }
+}
+
+function assertSize (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('"size" argument must be a number')
+ } else if (size < 0) {
+ throw new RangeError('"size" argument must not be negative')
+ }
+}
+
+function alloc (that, size, fill, encoding) {
+ assertSize(size)
+ if (size <= 0) {
+ return createBuffer(that, size)
+ }
+ if (fill !== undefined) {
+ // Only pay attention to encoding if it's a string. This
+ // prevents accidentally sending in a number that would
+ // be interpretted as a start offset.
+ return typeof encoding === 'string'
+ ? createBuffer(that, size).fill(fill, encoding)
+ : createBuffer(that, size).fill(fill)
+ }
+ return createBuffer(that, size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+ return alloc(null, size, fill, encoding)
+}
+
+function allocUnsafe (that, size) {
+ assertSize(size)
+ that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
+ if (!Buffer.TYPED_ARRAY_SUPPORT) {
+ for (var i = 0; i < size; ++i) {
+ that[i] = 0
+ }
+ }
+ return that
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+ return allocUnsafe(null, size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+ return allocUnsafe(null, size)
+}
+
+function fromString (that, string, encoding) {
+ if (typeof encoding !== 'string' || encoding === '') {
+ encoding = 'utf8'
+ }
+
+ if (!Buffer.isEncoding(encoding)) {
+ throw new TypeError('"encoding" must be a valid string encoding')
+ }
+
+ var length = byteLength(string, encoding) | 0
+ that = createBuffer(that, length)
+
+ var actual = that.write(string, encoding)
+
+ if (actual !== length) {
+ // Writing a hex string, for example, that contains invalid characters will
+ // cause everything after the first invalid character to be ignored. (e.g.
+ // 'abxxcd' will be treated as 'ab')
+ that = that.slice(0, actual)
+ }
+
+ return that
+}
+
+function fromArrayLike (that, array) {
+ var length = array.length < 0 ? 0 : checked(array.length) | 0
+ that = createBuffer(that, length)
+ for (var i = 0; i < length; i += 1) {
+ that[i] = array[i] & 255
+ }
+ return that
+}
+
+function fromArrayBuffer (that, array, byteOffset, length) {
+ array.byteLength // this throws if `array` is not a valid ArrayBuffer
+
+ if (byteOffset < 0 || array.byteLength < byteOffset) {
+ throw new RangeError('\'offset\' is out of bounds')
+ }
+
+ if (array.byteLength < byteOffset + (length || 0)) {
+ throw new RangeError('\'length\' is out of bounds')
+ }
+
+ if (byteOffset === undefined && length === undefined) {
+ array = new Uint8Array(array)
+ } else if (length === undefined) {
+ array = new Uint8Array(array, byteOffset)
+ } else {
+ array = new Uint8Array(array, byteOffset, length)
+ }
+
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ // Return an augmented `Uint8Array` instance, for best performance
+ that = array
+ that.__proto__ = Buffer.prototype
+ } else {
+ // Fallback: Return an object instance of the Buffer class
+ that = fromArrayLike(that, array)
+ }
+ return that
+}
+
+function fromObject (that, obj) {
+ if (Buffer.isBuffer(obj)) {
+ var len = checked(obj.length) | 0
+ that = createBuffer(that, len)
+
+ if (that.length === 0) {
+ return that
+ }
+
+ obj.copy(that, 0, 0, len)
+ return that
+ }
+
+ if (obj) {
+ if ((typeof ArrayBuffer !== 'undefined' &&
+ obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
+ if (typeof obj.length !== 'number' || isnan(obj.length)) {
+ return createBuffer(that, 0)
+ }
+ return fromArrayLike(that, obj)
+ }
+
+ if (obj.type === 'Buffer' && isArray(obj.data)) {
+ return fromArrayLike(that, obj.data)
+ }
+ }
+
+ throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
+}
+
+function checked (length) {
+ // Note: cannot use `length < kMaxLength()` here because that fails when
+ // length is NaN (which is otherwise coerced to zero.)
+ if (length >= kMaxLength()) {
+ throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+ 'size: 0x' + kMaxLength().toString(16) + ' bytes')
+ }
+ return length | 0
+}
+
+function SlowBuffer (length) {
+ if (+length != length) { // eslint-disable-line eqeqeq
+ length = 0
+ }
+ return Buffer.alloc(+length)
+}
+
+Buffer.isBuffer = function isBuffer (b) {
+ return !!(b != null && b._isBuffer)
+}
+
+Buffer.compare = function compare (a, b) {
+ if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+ throw new TypeError('Arguments must be Buffers')
+ }
+
+ if (a === b) return 0
+
+ var x = a.length
+ var y = b.length
+
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i]
+ y = b[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+Buffer.isEncoding = function isEncoding (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ case 'base64':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
+
+Buffer.concat = function concat (list, length) {
+ if (!isArray(list)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+
+ if (list.length === 0) {
+ return Buffer.alloc(0)
+ }
+
+ var i
+ if (length === undefined) {
+ length = 0
+ for (i = 0; i < list.length; ++i) {
+ length += list[i].length
+ }
+ }
+
+ var buffer = Buffer.allocUnsafe(length)
+ var pos = 0
+ for (i = 0; i < list.length; ++i) {
+ var buf = list[i]
+ if (!Buffer.isBuffer(buf)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+ buf.copy(buffer, pos)
+ pos += buf.length
+ }
+ return buffer
+}
+
+function byteLength (string, encoding) {
+ if (Buffer.isBuffer(string)) {
+ return string.length
+ }
+ if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
+ (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
+ return string.byteLength
+ }
+ if (typeof string !== 'string') {
+ string = '' + string
+ }
+
+ var len = string.length
+ if (len === 0) return 0
+
+ // Use a for loop to avoid recursion
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ return len
+ case 'utf8':
+ case 'utf-8':
+ case undefined:
+ return utf8ToBytes(string).length
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return len * 2
+ case 'hex':
+ return len >>> 1
+ case 'base64':
+ return base64ToBytes(string).length
+ default:
+ if (loweredCase) return utf8ToBytes(string).length // assume utf8
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+Buffer.byteLength = byteLength
+
+function slowToString (encoding, start, end) {
+ var loweredCase = false
+
+ // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+ // property of a typed array.
+
+ // This behaves neither like String nor Uint8Array in that we set start/end
+ // to their upper/lower bounds if the value passed is out of range.
+ // undefined is handled specially as per ECMA-262 6th Edition,
+ // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+ if (start === undefined || start < 0) {
+ start = 0
+ }
+ // Return early if start > this.length. Done here to prevent potential uint32
+ // coercion fail below.
+ if (start > this.length) {
+ return ''
+ }
+
+ if (end === undefined || end > this.length) {
+ end = this.length
+ }
+
+ if (end <= 0) {
+ return ''
+ }
+
+ // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+ end >>>= 0
+ start >>>= 0
+
+ if (end <= start) {
+ return ''
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ while (true) {
+ switch (encoding) {
+ case 'hex':
+ return hexSlice(this, start, end)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Slice(this, start, end)
+
+ case 'ascii':
+ return asciiSlice(this, start, end)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Slice(this, start, end)
+
+ case 'base64':
+ return base64Slice(this, start, end)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return utf16leSlice(this, start, end)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = (encoding + '').toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
+// Buffer instances.
+Buffer.prototype._isBuffer = true
+
+function swap (b, n, m) {
+ var i = b[n]
+ b[n] = b[m]
+ b[m] = i
+}
+
+Buffer.prototype.swap16 = function swap16 () {
+ var len = this.length
+ if (len % 2 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 16-bits')
+ }
+ for (var i = 0; i < len; i += 2) {
+ swap(this, i, i + 1)
+ }
+ return this
+}
+
+Buffer.prototype.swap32 = function swap32 () {
+ var len = this.length
+ if (len % 4 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 32-bits')
+ }
+ for (var i = 0; i < len; i += 4) {
+ swap(this, i, i + 3)
+ swap(this, i + 1, i + 2)
+ }
+ return this
+}
+
+Buffer.prototype.swap64 = function swap64 () {
+ var len = this.length
+ if (len % 8 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 64-bits')
+ }
+ for (var i = 0; i < len; i += 8) {
+ swap(this, i, i + 7)
+ swap(this, i + 1, i + 6)
+ swap(this, i + 2, i + 5)
+ swap(this, i + 3, i + 4)
+ }
+ return this
+}
+
+Buffer.prototype.toString = function toString () {
+ var length = this.length | 0
+ if (length === 0) return ''
+ if (arguments.length === 0) return utf8Slice(this, 0, length)
+ return slowToString.apply(this, arguments)
+}
+
+Buffer.prototype.equals = function equals (b) {
+ if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+ if (this === b) return true
+ return Buffer.compare(this, b) === 0
+}
+
+Buffer.prototype.inspect = function inspect () {
+ var str = ''
+ var max = exports.INSPECT_MAX_BYTES
+ if (this.length > 0) {
+ str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
+ if (this.length > max) str += ' ... '
+ }
+ return ''
+}
+
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+ if (!Buffer.isBuffer(target)) {
+ throw new TypeError('Argument must be a Buffer')
+ }
+
+ if (start === undefined) {
+ start = 0
+ }
+ if (end === undefined) {
+ end = target ? target.length : 0
+ }
+ if (thisStart === undefined) {
+ thisStart = 0
+ }
+ if (thisEnd === undefined) {
+ thisEnd = this.length
+ }
+
+ if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+ throw new RangeError('out of range index')
+ }
+
+ if (thisStart >= thisEnd && start >= end) {
+ return 0
+ }
+ if (thisStart >= thisEnd) {
+ return -1
+ }
+ if (start >= end) {
+ return 1
+ }
+
+ start >>>= 0
+ end >>>= 0
+ thisStart >>>= 0
+ thisEnd >>>= 0
+
+ if (this === target) return 0
+
+ var x = thisEnd - thisStart
+ var y = end - start
+ var len = Math.min(x, y)
+
+ var thisCopy = this.slice(thisStart, thisEnd)
+ var targetCopy = target.slice(start, end)
+
+ for (var i = 0; i < len; ++i) {
+ if (thisCopy[i] !== targetCopy[i]) {
+ x = thisCopy[i]
+ y = targetCopy[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+ // Empty buffer means no match
+ if (buffer.length === 0) return -1
+
+ // Normalize byteOffset
+ if (typeof byteOffset === 'string') {
+ encoding = byteOffset
+ byteOffset = 0
+ } else if (byteOffset > 0x7fffffff) {
+ byteOffset = 0x7fffffff
+ } else if (byteOffset < -0x80000000) {
+ byteOffset = -0x80000000
+ }
+ byteOffset = +byteOffset // Coerce to Number.
+ if (isNaN(byteOffset)) {
+ // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+ byteOffset = dir ? 0 : (buffer.length - 1)
+ }
+
+ // Normalize byteOffset: negative offsets start from the end of the buffer
+ if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+ if (byteOffset >= buffer.length) {
+ if (dir) return -1
+ else byteOffset = buffer.length - 1
+ } else if (byteOffset < 0) {
+ if (dir) byteOffset = 0
+ else return -1
+ }
+
+ // Normalize val
+ if (typeof val === 'string') {
+ val = Buffer.from(val, encoding)
+ }
+
+ // Finally, search either indexOf (if dir is true) or lastIndexOf
+ if (Buffer.isBuffer(val)) {
+ // Special case: looking for empty string/buffer always fails
+ if (val.length === 0) {
+ return -1
+ }
+ return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+ } else if (typeof val === 'number') {
+ val = val & 0xFF // Search for a byte value [0-255]
+ if (Buffer.TYPED_ARRAY_SUPPORT &&
+ typeof Uint8Array.prototype.indexOf === 'function') {
+ if (dir) {
+ return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+ } else {
+ return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+ }
+ }
+ return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
+ }
+
+ throw new TypeError('val must be string, number or Buffer')
+}
+
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+ var indexSize = 1
+ var arrLength = arr.length
+ var valLength = val.length
+
+ if (encoding !== undefined) {
+ encoding = String(encoding).toLowerCase()
+ if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+ encoding === 'utf16le' || encoding === 'utf-16le') {
+ if (arr.length < 2 || val.length < 2) {
+ return -1
+ }
+ indexSize = 2
+ arrLength /= 2
+ valLength /= 2
+ byteOffset /= 2
+ }
+ }
+
+ function read (buf, i) {
+ if (indexSize === 1) {
+ return buf[i]
+ } else {
+ return buf.readUInt16BE(i * indexSize)
+ }
+ }
+
+ var i
+ if (dir) {
+ var foundIndex = -1
+ for (i = byteOffset; i < arrLength; i++) {
+ if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+ if (foundIndex === -1) foundIndex = i
+ if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+ } else {
+ if (foundIndex !== -1) i -= i - foundIndex
+ foundIndex = -1
+ }
+ }
+ } else {
+ if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+ for (i = byteOffset; i >= 0; i--) {
+ var found = true
+ for (var j = 0; j < valLength; j++) {
+ if (read(arr, i + j) !== read(val, j)) {
+ found = false
+ break
+ }
+ }
+ if (found) return i
+ }
+ }
+
+ return -1
+}
+
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+ return this.indexOf(val, byteOffset, encoding) !== -1
+}
+
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
+
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
+
+function hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+
+ // must be an even number of digits
+ var strLen = string.length
+ if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
+
+ if (length > strLen / 2) {
+ length = strLen / 2
+ }
+ for (var i = 0; i < length; ++i) {
+ var parsed = parseInt(string.substr(i * 2, 2), 16)
+ if (isNaN(parsed)) return i
+ buf[offset + i] = parsed
+ }
+ return i
+}
+
+function utf8Write (buf, string, offset, length) {
+ return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+function asciiWrite (buf, string, offset, length) {
+ return blitBuffer(asciiToBytes(string), buf, offset, length)
+}
+
+function latin1Write (buf, string, offset, length) {
+ return asciiWrite(buf, string, offset, length)
+}
+
+function base64Write (buf, string, offset, length) {
+ return blitBuffer(base64ToBytes(string), buf, offset, length)
+}
+
+function ucs2Write (buf, string, offset, length) {
+ return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+Buffer.prototype.write = function write (string, offset, length, encoding) {
+ // Buffer#write(string)
+ if (offset === undefined) {
+ encoding = 'utf8'
+ length = this.length
+ offset = 0
+ // Buffer#write(string, encoding)
+ } else if (length === undefined && typeof offset === 'string') {
+ encoding = offset
+ length = this.length
+ offset = 0
+ // Buffer#write(string, offset[, length][, encoding])
+ } else if (isFinite(offset)) {
+ offset = offset | 0
+ if (isFinite(length)) {
+ length = length | 0
+ if (encoding === undefined) encoding = 'utf8'
+ } else {
+ encoding = length
+ length = undefined
+ }
+ // legacy write(string, encoding, offset, length) - remove in v0.13
+ } else {
+ throw new Error(
+ 'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+ )
+ }
+
+ var remaining = this.length - offset
+ if (length === undefined || length > remaining) length = remaining
+
+ if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+ throw new RangeError('Attempt to write outside buffer bounds')
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'hex':
+ return hexWrite(this, string, offset, length)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Write(this, string, offset, length)
+
+ case 'ascii':
+ return asciiWrite(this, string, offset, length)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Write(this, string, offset, length)
+
+ case 'base64':
+ // Warning: maxLength not taken into account in base64Write
+ return base64Write(this, string, offset, length)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return ucs2Write(this, string, offset, length)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+Buffer.prototype.toJSON = function toJSON () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+function base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
+ } else {
+ return base64.fromByteArray(buf.slice(start, end))
+ }
+}
+
+function utf8Slice (buf, start, end) {
+ end = Math.min(buf.length, end)
+ var res = []
+
+ var i = start
+ while (i < end) {
+ var firstByte = buf[i]
+ var codePoint = null
+ var bytesPerSequence = (firstByte > 0xEF) ? 4
+ : (firstByte > 0xDF) ? 3
+ : (firstByte > 0xBF) ? 2
+ : 1
+
+ if (i + bytesPerSequence <= end) {
+ var secondByte, thirdByte, fourthByte, tempCodePoint
+
+ switch (bytesPerSequence) {
+ case 1:
+ if (firstByte < 0x80) {
+ codePoint = firstByte
+ }
+ break
+ case 2:
+ secondByte = buf[i + 1]
+ if ((secondByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+ if (tempCodePoint > 0x7F) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 3:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+ if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 4:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ fourthByte = buf[i + 3]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+ if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+ codePoint = tempCodePoint
+ }
+ }
+ }
+ }
+
+ if (codePoint === null) {
+ // we did not generate a valid codePoint so insert a
+ // replacement char (U+FFFD) and advance only 1 byte
+ codePoint = 0xFFFD
+ bytesPerSequence = 1
+ } else if (codePoint > 0xFFFF) {
+ // encode to utf16 (surrogate pair dance)
+ codePoint -= 0x10000
+ res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+ codePoint = 0xDC00 | codePoint & 0x3FF
+ }
+
+ res.push(codePoint)
+ i += bytesPerSequence
+ }
+
+ return decodeCodePointsArray(res)
+}
+
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000
+
+function decodeCodePointsArray (codePoints) {
+ var len = codePoints.length
+ if (len <= MAX_ARGUMENTS_LENGTH) {
+ return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+ }
+
+ // Decode in chunks to avoid "call stack size exceeded".
+ var res = ''
+ var i = 0
+ while (i < len) {
+ res += String.fromCharCode.apply(
+ String,
+ codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+ )
+ }
+ return res
+}
+
+function asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i] & 0x7F)
+ }
+ return ret
+}
+
+function latin1Slice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i])
+ }
+ return ret
+}
+
+function hexSlice (buf, start, end) {
+ var len = buf.length
+
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
+
+ var out = ''
+ for (var i = start; i < end; ++i) {
+ out += toHex(buf[i])
+ }
+ return out
+}
+
+function utf16leSlice (buf, start, end) {
+ var bytes = buf.slice(start, end)
+ var res = ''
+ for (var i = 0; i < bytes.length; i += 2) {
+ res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
+ }
+ return res
+}
+
+Buffer.prototype.slice = function slice (start, end) {
+ var len = this.length
+ start = ~~start
+ end = end === undefined ? len : ~~end
+
+ if (start < 0) {
+ start += len
+ if (start < 0) start = 0
+ } else if (start > len) {
+ start = len
+ }
+
+ if (end < 0) {
+ end += len
+ if (end < 0) end = 0
+ } else if (end > len) {
+ end = len
+ }
+
+ if (end < start) end = start
+
+ var newBuf
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ newBuf = this.subarray(start, end)
+ newBuf.__proto__ = Buffer.prototype
+ } else {
+ var sliceLen = end - start
+ newBuf = new Buffer(sliceLen, undefined)
+ for (var i = 0; i < sliceLen; ++i) {
+ newBuf[i] = this[i + start]
+ }
+ }
+
+ return newBuf
+}
+
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+ if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+ if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+}
+
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) {
+ checkOffset(offset, byteLength, this.length)
+ }
+
+ var val = this[offset + --byteLength]
+ var mul = 1
+ while (byteLength > 0 && (mul *= 0x100)) {
+ val += this[offset + --byteLength] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ return this[offset]
+}
+
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return ((this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16)) +
+ (this[offset + 3] * 0x1000000)
+}
+
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] * 0x1000000) +
+ ((this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ this[offset + 3])
+}
+
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var i = byteLength
+ var mul = 1
+ var val = this[offset + --i]
+ while (i > 0 && (mul *= 0x100)) {
+ val += this[offset + --i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ if (!(this[offset] & 0x80)) return (this[offset])
+ return ((0xff - this[offset] + 1) * -1)
+}
+
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset] | (this[offset + 1] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset + 1] | (this[offset] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16) |
+ (this[offset + 3] << 24)
+}
+
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] << 24) |
+ (this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ (this[offset + 3])
+}
+
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, false, 52, 8)
+}
+
+function checkInt (buf, value, offset, ext, max, min) {
+ if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+ if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+}
+
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var mul = 1
+ var i = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+ if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+function objectWriteUInt16 (buf, value, offset, littleEndian) {
+ if (value < 0) value = 0xffff + value + 1
+ for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
+ buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+ (littleEndian ? i : 1 - i) * 8
+ }
+}
+
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ } else {
+ objectWriteUInt16(this, value, offset, true)
+ }
+ return offset + 2
+}
+
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ } else {
+ objectWriteUInt16(this, value, offset, false)
+ }
+ return offset + 2
+}
+
+function objectWriteUInt32 (buf, value, offset, littleEndian) {
+ if (value < 0) value = 0xffffffff + value + 1
+ for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
+ buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+ }
+}
+
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset + 3] = (value >>> 24)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 1] = (value >>> 8)
+ this[offset] = (value & 0xff)
+ } else {
+ objectWriteUInt32(this, value, offset, true)
+ }
+ return offset + 4
+}
+
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ } else {
+ objectWriteUInt32(this, value, offset, false)
+ }
+ return offset + 4
+}
+
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) {
+ var limit = Math.pow(2, 8 * byteLength - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = 0
+ var mul = 1
+ var sub = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) {
+ var limit = Math.pow(2, 8 * byteLength - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ var sub = 0
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+ if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+ if (value < 0) value = 0xff + value + 1
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ } else {
+ objectWriteUInt16(this, value, offset, true)
+ }
+ return offset + 2
+}
+
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ } else {
+ objectWriteUInt16(this, value, offset, false)
+ }
+ return offset + 2
+}
+
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 3] = (value >>> 24)
+ } else {
+ objectWriteUInt32(this, value, offset, true)
+ }
+ return offset + 4
+}
+
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ if (value < 0) value = 0xffffffff + value + 1
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ } else {
+ objectWriteUInt32(this, value, offset, false)
+ }
+ return offset + 4
+}
+
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+ if (offset < 0) throw new RangeError('Index out of range')
+}
+
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+ return offset + 4
+}
+
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, false, noAssert)
+}
+
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+ return offset + 8
+}
+
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, false, noAssert)
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (targetStart >= target.length) targetStart = target.length
+ if (!targetStart) targetStart = 0
+ if (end > 0 && end < start) end = start
+
+ // Copy 0 bytes; we're done
+ if (end === start) return 0
+ if (target.length === 0 || this.length === 0) return 0
+
+ // Fatal error conditions
+ if (targetStart < 0) {
+ throw new RangeError('targetStart out of bounds')
+ }
+ if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
+ if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+ // Are we oob?
+ if (end > this.length) end = this.length
+ if (target.length - targetStart < end - start) {
+ end = target.length - targetStart + start
+ }
+
+ var len = end - start
+ var i
+
+ if (this === target && start < targetStart && targetStart < end) {
+ // descending copy from end
+ for (i = len - 1; i >= 0; --i) {
+ target[i + targetStart] = this[i + start]
+ }
+ } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
+ // ascending copy from start
+ for (i = 0; i < len; ++i) {
+ target[i + targetStart] = this[i + start]
+ }
+ } else {
+ Uint8Array.prototype.set.call(
+ target,
+ this.subarray(start, start + len),
+ targetStart
+ )
+ }
+
+ return len
+}
+
+// Usage:
+// buffer.fill(number[, offset[, end]])
+// buffer.fill(buffer[, offset[, end]])
+// buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+ // Handle string cases:
+ if (typeof val === 'string') {
+ if (typeof start === 'string') {
+ encoding = start
+ start = 0
+ end = this.length
+ } else if (typeof end === 'string') {
+ encoding = end
+ end = this.length
+ }
+ if (val.length === 1) {
+ var code = val.charCodeAt(0)
+ if (code < 256) {
+ val = code
+ }
+ }
+ if (encoding !== undefined && typeof encoding !== 'string') {
+ throw new TypeError('encoding must be a string')
+ }
+ if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+ throw new TypeError('Unknown encoding: ' + encoding)
+ }
+ } else if (typeof val === 'number') {
+ val = val & 255
+ }
+
+ // Invalid ranges are not set to a default, so can range check early.
+ if (start < 0 || this.length < start || this.length < end) {
+ throw new RangeError('Out of range index')
+ }
+
+ if (end <= start) {
+ return this
+ }
+
+ start = start >>> 0
+ end = end === undefined ? this.length : end >>> 0
+
+ if (!val) val = 0
+
+ var i
+ if (typeof val === 'number') {
+ for (i = start; i < end; ++i) {
+ this[i] = val
+ }
+ } else {
+ var bytes = Buffer.isBuffer(val)
+ ? val
+ : utf8ToBytes(new Buffer(val, encoding).toString())
+ var len = bytes.length
+ for (i = 0; i < end - start; ++i) {
+ this[i + start] = bytes[i % len]
+ }
+ }
+
+ return this
+}
+
+// HELPER FUNCTIONS
+// ================
+
+var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
+
+function base64clean (str) {
+ // Node strips out invalid characters like \n and \t from the string, base64-js does not
+ str = stringtrim(str).replace(INVALID_BASE64_RE, '')
+ // Node converts strings with length < 2 to ''
+ if (str.length < 2) return ''
+ // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+ while (str.length % 4 !== 0) {
+ str = str + '='
+ }
+ return str
+}
+
+function stringtrim (str) {
+ if (str.trim) return str.trim()
+ return str.replace(/^\s+|\s+$/g, '')
+}
+
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
+}
+
+function utf8ToBytes (string, units) {
+ units = units || Infinity
+ var codePoint
+ var length = string.length
+ var leadSurrogate = null
+ var bytes = []
+
+ for (var i = 0; i < length; ++i) {
+ codePoint = string.charCodeAt(i)
+
+ // is surrogate component
+ if (codePoint > 0xD7FF && codePoint < 0xE000) {
+ // last char was a lead
+ if (!leadSurrogate) {
+ // no lead yet
+ if (codePoint > 0xDBFF) {
+ // unexpected trail
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ } else if (i + 1 === length) {
+ // unpaired lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ }
+
+ // valid lead
+ leadSurrogate = codePoint
+
+ continue
+ }
+
+ // 2 leads in a row
+ if (codePoint < 0xDC00) {
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ leadSurrogate = codePoint
+ continue
+ }
+
+ // valid surrogate pair
+ codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+ } else if (leadSurrogate) {
+ // valid bmp char, but last char was a lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ }
+
+ leadSurrogate = null
+
+ // encode utf8
+ if (codePoint < 0x80) {
+ if ((units -= 1) < 0) break
+ bytes.push(codePoint)
+ } else if (codePoint < 0x800) {
+ if ((units -= 2) < 0) break
+ bytes.push(
+ codePoint >> 0x6 | 0xC0,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x10000) {
+ if ((units -= 3) < 0) break
+ bytes.push(
+ codePoint >> 0xC | 0xE0,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x110000) {
+ if ((units -= 4) < 0) break
+ bytes.push(
+ codePoint >> 0x12 | 0xF0,
+ codePoint >> 0xC & 0x3F | 0x80,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else {
+ throw new Error('Invalid code point')
+ }
+ }
+
+ return bytes
+}
+
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ // Node's code seems to be doing this and not & 0x7F..
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
+
+function utf16leToBytes (str, units) {
+ var c, hi, lo
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ if ((units -= 2) < 0) break
+
+ c = str.charCodeAt(i)
+ hi = c >> 8
+ lo = c % 256
+ byteArray.push(lo)
+ byteArray.push(hi)
+ }
+
+ return byteArray
+}
+
+function base64ToBytes (str) {
+ return base64.toByteArray(base64clean(str))
+}
+
+function blitBuffer (src, dst, offset, length) {
+ for (var i = 0; i < length; ++i) {
+ if ((i + offset >= dst.length) || (i >= src.length)) break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
+
+function isnan (val) {
+ return val !== val // eslint-disable-line no-self-compare
+}
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "../node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
+/***/ "../node_modules/core-util-is/lib/util.js":
+/*!************************************************!*\
+ !*** ../node_modules/core-util-is/lib/util.js ***!
+ \************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(Buffer) {// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+
+function isArray(arg) {
+ if (Array.isArray) {
+ return Array.isArray(arg);
+ }
+ return objectToString(arg) === '[object Array]';
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = Buffer.isBuffer;
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../buffer/index.js */ "../node_modules/buffer/index.js").Buffer))
+
+/***/ }),
+
+/***/ "../node_modules/events/events.js":
+/*!****************************************!*\
+ !*** ../node_modules/events/events.js ***!
+ \****************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+
+
+var R = typeof Reflect === 'object' ? Reflect : null
+var ReflectApply = R && typeof R.apply === 'function'
+ ? R.apply
+ : function ReflectApply(target, receiver, args) {
+ return Function.prototype.apply.call(target, receiver, args);
+ }
+
+var ReflectOwnKeys
+if (R && typeof R.ownKeys === 'function') {
+ ReflectOwnKeys = R.ownKeys
+} else if (Object.getOwnPropertySymbols) {
+ ReflectOwnKeys = function ReflectOwnKeys(target) {
+ return Object.getOwnPropertyNames(target)
+ .concat(Object.getOwnPropertySymbols(target));
+ };
+} else {
+ ReflectOwnKeys = function ReflectOwnKeys(target) {
+ return Object.getOwnPropertyNames(target);
+ };
+}
+
+function ProcessEmitWarning(warning) {
+ if (console && console.warn) console.warn(warning);
+}
+
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+ return value !== value;
+}
+
+function EventEmitter() {
+ EventEmitter.init.call(this);
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+ enumerable: true,
+ get: function() {
+ return defaultMaxListeners;
+ },
+ set: function(arg) {
+ if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+ throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+ }
+ defaultMaxListeners = arg;
+ }
+});
+
+EventEmitter.init = function() {
+
+ if (this._events === undefined ||
+ this._events === Object.getPrototypeOf(this)._events) {
+ this._events = Object.create(null);
+ this._eventsCount = 0;
+ }
+
+ this._maxListeners = this._maxListeners || undefined;
+};
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+ if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+ throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+ }
+ this._maxListeners = n;
+ return this;
+};
+
+function $getMaxListeners(that) {
+ if (that._maxListeners === undefined)
+ return EventEmitter.defaultMaxListeners;
+ return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+ return $getMaxListeners(this);
+};
+
+EventEmitter.prototype.emit = function emit(type) {
+ var args = [];
+ for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+ var doError = (type === 'error');
+
+ var events = this._events;
+ if (events !== undefined)
+ doError = (doError && events.error === undefined);
+ else if (!doError)
+ return false;
+
+ // If there is no 'error' event listener then throw.
+ if (doError) {
+ var er;
+ if (args.length > 0)
+ er = args[0];
+ if (er instanceof Error) {
+ // Note: The comments on the `throw` lines are intentional, they show
+ // up in Node's output if this results in an unhandled exception.
+ throw er; // Unhandled 'error' event
+ }
+ // At least give some kind of context to the user
+ var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+ err.context = er;
+ throw err; // Unhandled 'error' event
+ }
+
+ var handler = events[type];
+
+ if (handler === undefined)
+ return false;
+
+ if (typeof handler === 'function') {
+ ReflectApply(handler, this, args);
+ } else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ ReflectApply(listeners[i], this, args);
+ }
+
+ return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+ var m;
+ var events;
+ var existing;
+
+ if (typeof listener !== 'function') {
+ throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+ }
+
+ events = target._events;
+ if (events === undefined) {
+ events = target._events = Object.create(null);
+ target._eventsCount = 0;
+ } else {
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (events.newListener !== undefined) {
+ target.emit('newListener', type,
+ listener.listener ? listener.listener : listener);
+
+ // Re-assign `events` because a newListener handler could have caused the
+ // this._events to be assigned to a new object
+ events = target._events;
+ }
+ existing = events[type];
+ }
+
+ if (existing === undefined) {
+ // Optimize the case of one listener. Don't need the extra array object.
+ existing = events[type] = listener;
+ ++target._eventsCount;
+ } else {
+ if (typeof existing === 'function') {
+ // Adding the second element, need to change to array.
+ existing = events[type] =
+ prepend ? [listener, existing] : [existing, listener];
+ // If we've already got an array, just append.
+ } else if (prepend) {
+ existing.unshift(listener);
+ } else {
+ existing.push(listener);
+ }
+
+ // Check for listener leak
+ m = $getMaxListeners(target);
+ if (m > 0 && existing.length > m && !existing.warned) {
+ existing.warned = true;
+ // No error code for this since it is a Warning
+ // eslint-disable-next-line no-restricted-syntax
+ var w = new Error('Possible EventEmitter memory leak detected. ' +
+ existing.length + ' ' + String(type) + ' listeners ' +
+ 'added. Use emitter.setMaxListeners() to ' +
+ 'increase limit');
+ w.name = 'MaxListenersExceededWarning';
+ w.emitter = target;
+ w.type = type;
+ w.count = existing.length;
+ ProcessEmitWarning(w);
+ }
+ }
+
+ return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+ return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener =
+ function prependListener(type, listener) {
+ return _addListener(this, type, listener, true);
+ };
+
+function onceWrapper() {
+ var args = [];
+ for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);
+ if (!this.fired) {
+ this.target.removeListener(this.type, this.wrapFn);
+ this.fired = true;
+ ReflectApply(this.listener, this.target, args);
+ }
+}
+
+function _onceWrap(target, type, listener) {
+ var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+ var wrapped = onceWrapper.bind(state);
+ wrapped.listener = listener;
+ state.wrapFn = wrapped;
+ return wrapped;
+}
+
+EventEmitter.prototype.once = function once(type, listener) {
+ if (typeof listener !== 'function') {
+ throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+ }
+ this.on(type, _onceWrap(this, type, listener));
+ return this;
+};
+
+EventEmitter.prototype.prependOnceListener =
+ function prependOnceListener(type, listener) {
+ if (typeof listener !== 'function') {
+ throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+ }
+ this.prependListener(type, _onceWrap(this, type, listener));
+ return this;
+ };
+
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+ function removeListener(type, listener) {
+ var list, events, position, i, originalListener;
+
+ if (typeof listener !== 'function') {
+ throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+ }
+
+ events = this._events;
+ if (events === undefined)
+ return this;
+
+ list = events[type];
+ if (list === undefined)
+ return this;
+
+ if (list === listener || list.listener === listener) {
+ if (--this._eventsCount === 0)
+ this._events = Object.create(null);
+ else {
+ delete events[type];
+ if (events.removeListener)
+ this.emit('removeListener', type, list.listener || listener);
+ }
+ } else if (typeof list !== 'function') {
+ position = -1;
+
+ for (i = list.length - 1; i >= 0; i--) {
+ if (list[i] === listener || list[i].listener === listener) {
+ originalListener = list[i].listener;
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (position === 0)
+ list.shift();
+ else {
+ spliceOne(list, position);
+ }
+
+ if (list.length === 1)
+ events[type] = list[0];
+
+ if (events.removeListener !== undefined)
+ this.emit('removeListener', type, originalListener || listener);
+ }
+
+ return this;
+ };
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners =
+ function removeAllListeners(type) {
+ var listeners, events, i;
+
+ events = this._events;
+ if (events === undefined)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (events.removeListener === undefined) {
+ if (arguments.length === 0) {
+ this._events = Object.create(null);
+ this._eventsCount = 0;
+ } else if (events[type] !== undefined) {
+ if (--this._eventsCount === 0)
+ this._events = Object.create(null);
+ else
+ delete events[type];
+ }
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ var keys = Object.keys(events);
+ var key;
+ for (i = 0; i < keys.length; ++i) {
+ key = keys[i];
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = Object.create(null);
+ this._eventsCount = 0;
+ return this;
+ }
+
+ listeners = events[type];
+
+ if (typeof listeners === 'function') {
+ this.removeListener(type, listeners);
+ } else if (listeners !== undefined) {
+ // LIFO order
+ for (i = listeners.length - 1; i >= 0; i--) {
+ this.removeListener(type, listeners[i]);
+ }
+ }
+
+ return this;
+ };
+
+function _listeners(target, type, unwrap) {
+ var events = target._events;
+
+ if (events === undefined)
+ return [];
+
+ var evlistener = events[type];
+ if (evlistener === undefined)
+ return [];
+
+ if (typeof evlistener === 'function')
+ return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+ return unwrap ?
+ unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+ return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+ return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ if (typeof emitter.listenerCount === 'function') {
+ return emitter.listenerCount(type);
+ } else {
+ return listenerCount.call(emitter, type);
+ }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+ var events = this._events;
+
+ if (events !== undefined) {
+ var evlistener = events[type];
+
+ if (typeof evlistener === 'function') {
+ return 1;
+ } else if (evlistener !== undefined) {
+ return evlistener.length;
+ }
+ }
+
+ return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+ return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+
+function arrayClone(arr, n) {
+ var copy = new Array(n);
+ for (var i = 0; i < n; ++i)
+ copy[i] = arr[i];
+ return copy;
+}
+
+function spliceOne(list, index) {
+ for (; index + 1 < list.length; index++)
+ list[index] = list[index + 1];
+ list.pop();
+}
+
+function unwrapListeners(arr) {
+ var ret = new Array(arr.length);
+ for (var i = 0; i < ret.length; ++i) {
+ ret[i] = arr[i].listener || arr[i];
+ }
+ return ret;
+}
+
+
+/***/ }),
+
+/***/ "../node_modules/ieee754/index.js":
+/*!****************************************!*\
+ !*** ../node_modules/ieee754/index.js ***!
+ \****************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+ var e, m
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var nBits = -7
+ var i = isLE ? (nBytes - 1) : 0
+ var d = isLE ? -1 : 1
+ var s = buffer[offset + i]
+
+ i += d
+
+ e = s & ((1 << (-nBits)) - 1)
+ s >>= (-nBits)
+ nBits += eLen
+ for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+ m = e & ((1 << (-nBits)) - 1)
+ e >>= (-nBits)
+ nBits += mLen
+ for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+ if (e === 0) {
+ e = 1 - eBias
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity)
+ } else {
+ m = m + Math.pow(2, mLen)
+ e = e - eBias
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+}
+
+exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+ var e, m, c
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+ var i = isLE ? 0 : (nBytes - 1)
+ var d = isLE ? 1 : -1
+ var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+ value = Math.abs(value)
+
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0
+ e = eMax
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2)
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--
+ c *= 2
+ }
+ if (e + eBias >= 1) {
+ value += rt / c
+ } else {
+ value += rt * Math.pow(2, 1 - eBias)
+ }
+ if (value * c >= 2) {
+ e++
+ c /= 2
+ }
+
+ if (e + eBias >= eMax) {
+ m = 0
+ e = eMax
+ } else if (e + eBias >= 1) {
+ m = ((value * c) - 1) * Math.pow(2, mLen)
+ e = e + eBias
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+ e = 0
+ }
+ }
+
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+ e = (e << mLen) | m
+ eLen += mLen
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+ buffer[offset + i - d] |= s * 128
+}
+
+
+/***/ }),
+
+/***/ "../node_modules/inherits/inherits_browser.js":
+/*!****************************************************!*\
+ !*** ../node_modules/inherits/inherits_browser.js ***!
+ \****************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+}
+
+
+/***/ }),
+
+/***/ "../node_modules/isarray/index.js":
+/*!****************************************!*\
+ !*** ../node_modules/isarray/index.js ***!
+ \****************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+var toString = {}.toString;
+
+module.exports = Array.isArray || function (arr) {
+ return toString.call(arr) == '[object Array]';
+};
+
+
+/***/ }),
+
+/***/ "../node_modules/msgpack5/index.js":
+/*!*****************************************!*\
+ !*** ../node_modules/msgpack5/index.js ***!
+ \*****************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var Buffer = __webpack_require__(/*! safe-buffer */ "../node_modules/safe-buffer/index.js").Buffer
+var assert = __webpack_require__(/*! assert */ "../node_modules/assert/assert.js")
+var bl = __webpack_require__(/*! bl */ "../node_modules/bl/bl.js")
+var streams = __webpack_require__(/*! ./lib/streams */ "../node_modules/msgpack5/lib/streams.js")
+var buildDecode = __webpack_require__(/*! ./lib/decoder */ "../node_modules/msgpack5/lib/decoder.js")
+var buildEncode = __webpack_require__(/*! ./lib/encoder */ "../node_modules/msgpack5/lib/encoder.js")
+
+function msgpack (options) {
+ var encodingTypes = []
+ var decodingTypes = []
+
+ options = options || {
+ forceFloat64: false,
+ compatibilityMode: false,
+ disableTimestampEncoding: false // if true, skips encoding Dates using the msgpack timestamp ext format (-1)
+ }
+
+ function registerEncoder (check, encode) {
+ assert(check, 'must have an encode function')
+ assert(encode, 'must have an encode function')
+
+ encodingTypes.push({
+ check: check, encode: encode
+ })
+
+ return this
+ }
+
+ function registerDecoder (type, decode) {
+ assert(type >= 0, 'must have a non-negative type')
+ assert(decode, 'must have a decode function')
+
+ decodingTypes.push({
+ type: type, decode: decode
+ })
+
+ return this
+ }
+
+ function register (type, constructor, encode, decode) {
+ assert(constructor, 'must have a constructor')
+ assert(encode, 'must have an encode function')
+ assert(type >= 0, 'must have a non-negative type')
+ assert(decode, 'must have a decode function')
+
+ function check (obj) {
+ return (obj instanceof constructor)
+ }
+
+ function reEncode (obj) {
+ var buf = bl()
+ var header = Buffer.allocUnsafe(1)
+
+ header.writeInt8(type, 0)
+
+ buf.append(header)
+ buf.append(encode(obj))
+
+ return buf
+ }
+
+ this.registerEncoder(check, reEncode)
+ this.registerDecoder(type, decode)
+
+ return this
+ }
+
+ return {
+ encode: buildEncode(encodingTypes, options.forceFloat64, options.compatibilityMode, options.disableTimestampEncoding),
+ decode: buildDecode(decodingTypes),
+ register: register,
+ registerEncoder: registerEncoder,
+ registerDecoder: registerDecoder,
+ encoder: streams.encoder,
+ decoder: streams.decoder,
+ // needed for levelup support
+ buffer: true,
+ type: 'msgpack5',
+ IncompleteBufferError: buildDecode.IncompleteBufferError
+ }
+}
+
+module.exports = msgpack
+
+
+/***/ }),
+
+/***/ "../node_modules/msgpack5/lib/decoder.js":
+/*!***********************************************!*\
+ !*** ../node_modules/msgpack5/lib/decoder.js ***!
+ \***********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var bl = __webpack_require__(/*! bl */ "../node_modules/bl/bl.js")
+var util = __webpack_require__(/*! util */ "../node_modules/util/util.js")
+
+function IncompleteBufferError (message) {
+ Error.call(this) // super constructor
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, this.constructor) // super helper method to include stack trace in error object
+ }
+ this.name = this.constructor.name
+ this.message = message || 'unable to decode'
+}
+
+util.inherits(IncompleteBufferError, Error)
+
+module.exports = function buildDecode (decodingTypes) {
+ return decode
+
+ function getSize (first) {
+ switch (first) {
+ case 0xc4:
+ return 2
+ case 0xc5:
+ return 3
+ case 0xc6:
+ return 5
+ case 0xc7:
+ return 3
+ case 0xc8:
+ return 4
+ case 0xc9:
+ return 6
+ case 0xca:
+ return 5
+ case 0xcb:
+ return 9
+ case 0xcc:
+ return 2
+ case 0xcd:
+ return 3
+ case 0xce:
+ return 5
+ case 0xcf:
+ return 9
+ case 0xd0:
+ return 2
+ case 0xd1:
+ return 3
+ case 0xd2:
+ return 5
+ case 0xd3:
+ return 9
+ case 0xd4:
+ return 3
+ case 0xd5:
+ return 4
+ case 0xd6:
+ return 6
+ case 0xd7:
+ return 10
+ case 0xd8:
+ return 18
+ case 0xd9:
+ return 2
+ case 0xda:
+ return 3
+ case 0xdb:
+ return 5
+ case 0xde:
+ return 3
+ default:
+ return -1
+ }
+ }
+
+ function hasMinBufferSize (first, length) {
+ var size = getSize(first)
+
+ if (size !== -1 && length < size) {
+ return false
+ } else {
+ return true
+ }
+ }
+
+ function isValidDataSize (dataLength, bufLength, headerLength) {
+ return bufLength >= headerLength + dataLength
+ }
+
+ function buildDecodeResult (value, bytesConsumed) {
+ return {
+ value: value,
+ bytesConsumed: bytesConsumed
+ }
+ }
+
+ function decode (buf) {
+ if (!(buf instanceof bl)) {
+ buf = bl().append(buf)
+ }
+
+ var result = tryDecode(buf)
+ if (result) {
+ buf.consume(result.bytesConsumed)
+ return result.value
+ } else {
+ throw new IncompleteBufferError()
+ }
+ }
+
+ function tryDecode (buf, offset) {
+ offset = offset === undefined ? 0 : offset
+ var bufLength = buf.length - offset
+ if (bufLength <= 0) {
+ return null
+ }
+
+ var first = buf.readUInt8(offset)
+ var length
+ var result = 0
+ var type
+ var bytePos
+
+ if (!hasMinBufferSize(first, bufLength)) {
+ return null
+ }
+
+ switch (first) {
+ case 0xc0:
+ return buildDecodeResult(null, 1)
+ case 0xc2:
+ return buildDecodeResult(false, 1)
+ case 0xc3:
+ return buildDecodeResult(true, 1)
+ case 0xcc:
+ // 1-byte unsigned int
+ result = buf.readUInt8(offset + 1)
+ return buildDecodeResult(result, 2)
+ case 0xcd:
+ // 2-bytes BE unsigned int
+ result = buf.readUInt16BE(offset + 1)
+ return buildDecodeResult(result, 3)
+ case 0xce:
+ // 4-bytes BE unsigned int
+ result = buf.readUInt32BE(offset + 1)
+ return buildDecodeResult(result, 5)
+ case 0xcf:
+ // 8-bytes BE unsigned int
+ // Read long byte by byte, big-endian
+ for (bytePos = 7; bytePos >= 0; bytePos--) {
+ result += (buf.readUInt8(offset + bytePos + 1) * Math.pow(2, (8 * (7 - bytePos))))
+ }
+ return buildDecodeResult(result, 9)
+ case 0xd0:
+ // 1-byte signed int
+ result = buf.readInt8(offset + 1)
+ return buildDecodeResult(result, 2)
+ case 0xd1:
+ // 2-bytes signed int
+ result = buf.readInt16BE(offset + 1)
+ return buildDecodeResult(result, 3)
+ case 0xd2:
+ // 4-bytes signed int
+ result = buf.readInt32BE(offset + 1)
+ return buildDecodeResult(result, 5)
+ case 0xd3:
+ result = readInt64BE(buf.slice(offset + 1, offset + 9), 0)
+ return buildDecodeResult(result, 9)
+ case 0xca:
+ // 4-bytes float
+ result = buf.readFloatBE(offset + 1)
+ return buildDecodeResult(result, 5)
+ case 0xcb:
+ // 8-bytes double
+ result = buf.readDoubleBE(offset + 1)
+ return buildDecodeResult(result, 9)
+ case 0xd9:
+ // strings up to 2^8 - 1 bytes
+ length = buf.readUInt8(offset + 1)
+ if (!isValidDataSize(length, bufLength, 2)) {
+ return null
+ }
+ result = buf.toString('utf8', offset + 2, offset + 2 + length)
+ return buildDecodeResult(result, 2 + length)
+ case 0xda:
+ // strings up to 2^16 - 2 bytes
+ length = buf.readUInt16BE(offset + 1)
+ if (!isValidDataSize(length, bufLength, 3)) {
+ return null
+ }
+ result = buf.toString('utf8', offset + 3, offset + 3 + length)
+ return buildDecodeResult(result, 3 + length)
+ case 0xdb:
+ // strings up to 2^32 - 4 bytes
+ length = buf.readUInt32BE(offset + 1)
+ if (!isValidDataSize(length, bufLength, 5)) {
+ return null
+ }
+ result = buf.toString('utf8', offset + 5, offset + 5 + length)
+ return buildDecodeResult(result, 5 + length)
+ case 0xc4:
+ // buffers up to 2^8 - 1 bytes
+ length = buf.readUInt8(offset + 1)
+ if (!isValidDataSize(length, bufLength, 2)) {
+ return null
+ }
+ result = buf.slice(offset + 2, offset + 2 + length)
+ return buildDecodeResult(result, 2 + length)
+ case 0xc5:
+ // buffers up to 2^16 - 1 bytes
+ length = buf.readUInt16BE(offset + 1)
+ if (!isValidDataSize(length, bufLength, 3)) {
+ return null
+ }
+ result = buf.slice(offset + 3, offset + 3 + length)
+ return buildDecodeResult(result, 3 + length)
+ case 0xc6:
+ // buffers up to 2^32 - 1 bytes
+ length = buf.readUInt32BE(offset + 1)
+ if (!isValidDataSize(length, bufLength, 5)) {
+ return null
+ }
+ result = buf.slice(offset + 5, offset + 5 + length)
+ return buildDecodeResult(result, 5 + length)
+ case 0xdc:
+ // array up to 2^16 elements - 2 bytes
+ if (bufLength < 3) {
+ return null
+ }
+
+ length = buf.readUInt16BE(offset + 1)
+ return decodeArray(buf, offset, length, 3)
+ case 0xdd:
+ // array up to 2^32 elements - 4 bytes
+ if (bufLength < 5) {
+ return null
+ }
+
+ length = buf.readUInt32BE(offset + 1)
+ return decodeArray(buf, offset, length, 5)
+ case 0xde:
+ // maps up to 2^16 elements - 2 bytes
+ length = buf.readUInt16BE(offset + 1)
+ return decodeMap(buf, offset, length, 3)
+ case 0xdf:
+ length = buf.readUInt32BE(offset + 1)
+ return decodeMap(buf, offset, length, 5)
+ case 0xd4:
+ return decodeFixExt(buf, offset, 1)
+ case 0xd5:
+ return decodeFixExt(buf, offset, 2)
+ case 0xd6:
+ return decodeFixExt(buf, offset, 4)
+ case 0xd7:
+ return decodeFixExt(buf, offset, 8)
+ case 0xd8:
+ return decodeFixExt(buf, offset, 16)
+ case 0xc7:
+ // ext up to 2^8 - 1 bytes
+ length = buf.readUInt8(offset + 1)
+ type = buf.readUInt8(offset + 2)
+ if (!isValidDataSize(length, bufLength, 3)) {
+ return null
+ }
+ return decodeExt(buf, offset, type, length, 3)
+ case 0xc8:
+ // ext up to 2^16 - 1 bytes
+ length = buf.readUInt16BE(offset + 1)
+ type = buf.readUInt8(offset + 3)
+ if (!isValidDataSize(length, bufLength, 4)) {
+ return null
+ }
+ return decodeExt(buf, offset, type, length, 4)
+ case 0xc9:
+ // ext up to 2^32 - 1 bytes
+ length = buf.readUInt32BE(offset + 1)
+ type = buf.readUInt8(offset + 5)
+ if (!isValidDataSize(length, bufLength, 6)) {
+ return null
+ }
+ return decodeExt(buf, offset, type, length, 6)
+ }
+
+ if ((first & 0xf0) === 0x90) {
+ // we have an array with less than 15 elements
+ length = first & 0x0f
+ return decodeArray(buf, offset, length, 1)
+ } else if ((first & 0xf0) === 0x80) {
+ // we have a map with less than 15 elements
+ length = first & 0x0f
+ return decodeMap(buf, offset, length, 1)
+ } else if ((first & 0xe0) === 0xa0) {
+ // fixstr up to 31 bytes
+ length = first & 0x1f
+ if (isValidDataSize(length, bufLength, 1)) {
+ result = buf.toString('utf8', offset + 1, offset + length + 1)
+ return buildDecodeResult(result, length + 1)
+ } else {
+ return null
+ }
+ } else if (first >= 0xe0) {
+ // 5 bits negative ints
+ result = first - 0x100
+ return buildDecodeResult(result, 1)
+ } else if (first < 0x80) {
+ // 7-bits positive ints
+ return buildDecodeResult(first, 1)
+ } else {
+ throw new Error('not implemented yet')
+ }
+ }
+
+ function readInt64BE (buf, offset) {
+ var negate = (buf[offset] & 0x80) == 0x80 // eslint-disable-line
+
+ if (negate) {
+ var carry = 1
+ for (var i = offset + 7; i >= offset; i--) {
+ var v = (buf[i] ^ 0xff) + carry
+ buf[i] = v & 0xff
+ carry = v >> 8
+ }
+ }
+
+ var hi = buf.readUInt32BE(offset + 0)
+ var lo = buf.readUInt32BE(offset + 4)
+ return (hi * 4294967296 + lo) * (negate ? -1 : +1)
+ }
+
+ function decodeArray (buf, offset, length, headerLength) {
+ var result = []
+ var i
+ var totalBytesConsumed = 0
+
+ offset += headerLength
+ for (i = 0; i < length; i++) {
+ var decodeResult = tryDecode(buf, offset)
+ if (decodeResult) {
+ result.push(decodeResult.value)
+ offset += decodeResult.bytesConsumed
+ totalBytesConsumed += decodeResult.bytesConsumed
+ } else {
+ return null
+ }
+ }
+ return buildDecodeResult(result, headerLength + totalBytesConsumed)
+ }
+
+ function decodeMap (buf, offset, length, headerLength) {
+ var result = {}
+ var key
+ var i
+ var totalBytesConsumed = 0
+
+ offset += headerLength
+ for (i = 0; i < length; i++) {
+ var keyResult = tryDecode(buf, offset)
+ if (keyResult) {
+ offset += keyResult.bytesConsumed
+ var valueResult = tryDecode(buf, offset)
+ if (valueResult) {
+ key = keyResult.value
+ result[key] = valueResult.value
+ offset += valueResult.bytesConsumed
+ totalBytesConsumed += (keyResult.bytesConsumed + valueResult.bytesConsumed)
+ } else {
+ return null
+ }
+ } else {
+ return null
+ }
+ }
+ return buildDecodeResult(result, headerLength + totalBytesConsumed)
+ }
+
+ function decodeFixExt (buf, offset, size) {
+ var type = buf.readInt8(offset + 1) // Signed
+ return decodeExt(buf, offset, type, size, 2)
+ }
+
+ function decodeTimestamp (buf, size, headerSize) {
+ var seconds
+ var nanoseconds = 0
+
+ switch (size) {
+ case 4:
+ // timestamp 32 stores the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC in an 32-bit unsigned integer
+ seconds = buf.readUInt32BE(0)
+ break
+
+ case 8:
+ // Timestamp 64 stores the number of seconds and nanoseconds that have elapsed
+ // since 1970-01-01 00:00:00 UTC in 32-bit unsigned integers, split 30/34 bits
+ var upper = buf.readUInt32BE(0)
+ var lower = buf.readUInt32BE(4)
+ nanoseconds = upper / 4
+ seconds = ((upper & 0x03) * Math.pow(2, 32)) + lower // If we use bitwise operators, we get truncated to 32bits
+ break
+
+ case 12:
+ throw new Error('timestamp 96 is not yet implemented')
+ }
+
+ var millis = (seconds * 1000) + Math.round(nanoseconds / 1E6)
+ return buildDecodeResult(new Date(millis), size + headerSize)
+ }
+
+ function decodeExt (buf, offset, type, size, headerSize) {
+ var i,
+ toDecode
+
+ offset += headerSize
+
+ // Pre-defined
+ if (type < 0) { // Reserved for future extensions
+ switch (type) {
+ case -1: // Tiemstamp https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
+ toDecode = buf.slice(offset, offset + size)
+ return decodeTimestamp(toDecode, size, headerSize)
+ }
+ }
+
+ for (i = 0; i < decodingTypes.length; i++) {
+ if (type === decodingTypes[i].type) {
+ toDecode = buf.slice(offset, offset + size)
+ var value = decodingTypes[i].decode(toDecode)
+ return buildDecodeResult(value, headerSize + size)
+ }
+ }
+
+ throw new Error('unable to find ext type ' + type)
+ }
+}
+
+module.exports.IncompleteBufferError = IncompleteBufferError
+
+
+/***/ }),
+
+/***/ "../node_modules/msgpack5/lib/encoder.js":
+/*!***********************************************!*\
+ !*** ../node_modules/msgpack5/lib/encoder.js ***!
+ \***********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var Buffer = __webpack_require__(/*! safe-buffer */ "../node_modules/safe-buffer/index.js").Buffer
+var bl = __webpack_require__(/*! bl */ "../node_modules/bl/bl.js")
+
+module.exports = function buildEncode (encodingTypes, forceFloat64, compatibilityMode, disableTimestampEncoding) {
+ function encode (obj, avoidSlice) {
+ var buf
+ var len
+
+ if (obj === undefined) {
+ throw new Error('undefined is not encodable in msgpack!')
+ } else if (isNaN(obj)) {
+ throw new Error('NaN is not encodable in msgpack!')
+ } else if (obj === null) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0xc0
+ } else if (obj === true) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0xc3
+ } else if (obj === false) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0xc2
+ } else if (typeof obj === 'string') {
+ len = Buffer.byteLength(obj)
+ if (len < 32) {
+ buf = Buffer.allocUnsafe(1 + len)
+ buf[0] = 0xa0 | len
+ if (len > 0) {
+ buf.write(obj, 1)
+ }
+ } else if (len <= 0xff && !compatibilityMode) {
+ // str8, but only when not in compatibility mode
+ buf = Buffer.allocUnsafe(2 + len)
+ buf[0] = 0xd9
+ buf[1] = len
+ buf.write(obj, 2)
+ } else if (len <= 0xffff) {
+ buf = Buffer.allocUnsafe(3 + len)
+ buf[0] = 0xda
+ buf.writeUInt16BE(len, 1)
+ buf.write(obj, 3)
+ } else {
+ buf = Buffer.allocUnsafe(5 + len)
+ buf[0] = 0xdb
+ buf.writeUInt32BE(len, 1)
+ buf.write(obj, 5)
+ }
+ } else if (obj && (obj.readUInt32LE || obj instanceof Uint8Array)) {
+ if (obj instanceof Uint8Array) {
+ obj = Buffer.from(obj)
+ }
+ // weird hack to support Buffer
+ // and Buffer-like objects
+ if (obj.length <= 0xff) {
+ buf = Buffer.allocUnsafe(2)
+ buf[0] = 0xc4
+ buf[1] = obj.length
+ } else if (obj.length <= 0xffff) {
+ buf = Buffer.allocUnsafe(3)
+ buf[0] = 0xc5
+ buf.writeUInt16BE(obj.length, 1)
+ } else {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xc6
+ buf.writeUInt32BE(obj.length, 1)
+ }
+
+ buf = bl([buf, obj])
+ } else if (Array.isArray(obj)) {
+ if (obj.length < 16) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0x90 | obj.length
+ } else if (obj.length < 65536) {
+ buf = Buffer.allocUnsafe(3)
+ buf[0] = 0xdc
+ buf.writeUInt16BE(obj.length, 1)
+ } else {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xdd
+ buf.writeUInt32BE(obj.length, 1)
+ }
+
+ buf = obj.reduce(function (acc, obj) {
+ acc.append(encode(obj, true))
+ return acc
+ }, bl().append(buf))
+ } else if (!disableTimestampEncoding && typeof obj.getDate === 'function') {
+ return encodeDate(obj)
+ } else if (typeof obj === 'object') {
+ buf = encodeExt(obj) || encodeObject(obj)
+ } else if (typeof obj === 'number') {
+ if (isFloat(obj)) {
+ return encodeFloat(obj, forceFloat64)
+ } else if (obj >= 0) {
+ if (obj < 128) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = obj
+ } else if (obj < 256) {
+ buf = Buffer.allocUnsafe(2)
+ buf[0] = 0xcc
+ buf[1] = obj
+ } else if (obj < 65536) {
+ buf = Buffer.allocUnsafe(3)
+ buf[0] = 0xcd
+ buf.writeUInt16BE(obj, 1)
+ } else if (obj <= 0xffffffff) {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xce
+ buf.writeUInt32BE(obj, 1)
+ } else if (obj <= 9007199254740991) {
+ buf = Buffer.allocUnsafe(9)
+ buf[0] = 0xcf
+ write64BitUint(buf, obj)
+ } else {
+ return encodeFloat(obj, true)
+ }
+ } else {
+ if (obj >= -32) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0x100 + obj
+ } else if (obj >= -128) {
+ buf = Buffer.allocUnsafe(2)
+ buf[0] = 0xd0
+ buf.writeInt8(obj, 1)
+ } else if (obj >= -32768) {
+ buf = Buffer.allocUnsafe(3)
+ buf[0] = 0xd1
+ buf.writeInt16BE(obj, 1)
+ } else if (obj > -214748365) {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xd2
+ buf.writeInt32BE(obj, 1)
+ } else if (obj >= -9007199254740991) {
+ buf = Buffer.allocUnsafe(9)
+ buf[0] = 0xd3
+ write64BitInt(buf, 1, obj)
+ } else {
+ return encodeFloat(obj, true)
+ }
+ }
+ }
+
+ if (!buf) {
+ throw new Error('not implemented yet')
+ }
+
+ if (avoidSlice) {
+ return buf
+ } else {
+ return buf.slice()
+ }
+ }
+
+ function encodeDate (dt) {
+ var encoded
+ var millis = dt * 1
+ var seconds = Math.floor(millis / 1000)
+ var nanos = (millis - (seconds * 1000)) * 1E6
+
+ if (nanos || seconds > 0xFFFFFFFF) {
+ // Timestamp64
+ encoded = Buffer.allocUnsafe(10)
+ encoded[0] = 0xd7
+ encoded[1] = -1
+
+ var upperNanos = ((nanos * 4))
+ var upperSeconds = seconds / Math.pow(2, 32)
+ var upper = (upperNanos + upperSeconds) & 0xFFFFFFFF
+ var lower = seconds & 0xFFFFFFFF
+
+ encoded.writeInt32BE(upper, 2)
+ encoded.writeInt32BE(lower, 6)
+ } else {
+ // Timestamp32
+ encoded = Buffer.allocUnsafe(6)
+ encoded[0] = 0xd6
+ encoded[1] = -1
+ encoded.writeUInt32BE(Math.floor(millis / 1000), 2)
+ }
+ return bl().append(encoded)
+ }
+
+ function encodeExt (obj) {
+ var i
+ var encoded
+ var length = -1
+ var headers = []
+
+ for (i = 0; i < encodingTypes.length; i++) {
+ if (encodingTypes[i].check(obj)) {
+ encoded = encodingTypes[i].encode(obj)
+ break
+ }
+ }
+
+ if (!encoded) {
+ return null
+ }
+
+ // we subtract 1 because the length does not
+ // include the type
+ length = encoded.length - 1
+
+ if (length === 1) {
+ headers.push(0xd4)
+ } else if (length === 2) {
+ headers.push(0xd5)
+ } else if (length === 4) {
+ headers.push(0xd6)
+ } else if (length === 8) {
+ headers.push(0xd7)
+ } else if (length === 16) {
+ headers.push(0xd8)
+ } else if (length < 256) {
+ headers.push(0xc7)
+ headers.push(length)
+ } else if (length < 0x10000) {
+ headers.push(0xc8)
+ headers.push(length >> 8)
+ headers.push(length & 0x00ff)
+ } else {
+ headers.push(0xc9)
+ headers.push(length >> 24)
+ headers.push((length >> 16) & 0x000000ff)
+ headers.push((length >> 8) & 0x000000ff)
+ headers.push(length & 0x000000ff)
+ }
+
+ return bl().append(Buffer.from(headers)).append(encoded)
+ }
+
+ function encodeObject (obj) {
+ var acc = []
+ var length = 0
+ var key
+ var header
+
+ for (key in obj) {
+ if (obj.hasOwnProperty(key) &&
+ obj[key] !== undefined &&
+ typeof obj[key] !== 'function') {
+ ++length
+ acc.push(encode(key, true))
+ acc.push(encode(obj[key], true))
+ }
+ }
+
+ if (length < 16) {
+ header = Buffer.allocUnsafe(1)
+ header[0] = 0x80 | length
+ } else if (length < 0xFFFF) {
+ header = Buffer.allocUnsafe(3)
+ header[0] = 0xde
+ header.writeUInt16BE(length, 1)
+ } else {
+ header = Buffer.allocUnsafe(5)
+ header[0] = 0xdf
+ header.writeUInt32BE(length, 1)
+ }
+
+ acc.unshift(header)
+
+ var result = acc.reduce(function (list, buf) {
+ return list.append(buf)
+ }, bl())
+
+ return result
+ }
+
+ return encode
+}
+
+function write64BitUint (buf, obj) {
+ // Write long byte by byte, in big-endian order
+ for (var currByte = 7; currByte >= 0; currByte--) {
+ buf[currByte + 1] = (obj & 0xff)
+ obj = obj / 256
+ }
+}
+
+function write64BitInt (buf, offset, num) {
+ var negate = num < 0
+
+ if (negate) {
+ num = Math.abs(num)
+ }
+
+ var lo = num % 4294967296
+ var hi = num / 4294967296
+ buf.writeUInt32BE(Math.floor(hi), offset + 0)
+ buf.writeUInt32BE(lo, offset + 4)
+
+ if (negate) {
+ var carry = 1
+ for (var i = offset + 7; i >= offset; i--) {
+ var v = (buf[i] ^ 0xff) + carry
+ buf[i] = v & 0xff
+ carry = v >> 8
+ }
+ }
+}
+
+function isFloat (n) {
+ return n % 1 !== 0
+}
+
+function isNaN (n) {
+ /* eslint-disable no-self-compare */
+ return n !== n && typeof n === 'number'
+ /* eslint-enable no-self-compare */
+}
+
+function encodeFloat (obj, forceFloat64) {
+ var useDoublePrecision = true
+
+ // If `fround` is supported, we can check if a float
+ // is double or single precision by rounding the object
+ // to single precision and comparing the difference.
+ // If it's not supported, it's safer to use a 64 bit
+ // float so we don't lose precision without meaning to.
+ if (Math.fround) {
+ useDoublePrecision = Math.fround(obj) !== obj
+ }
+
+ if (forceFloat64) {
+ useDoublePrecision = true
+ }
+
+ var buf
+
+ if (useDoublePrecision) {
+ buf = Buffer.allocUnsafe(9)
+ buf[0] = 0xcb
+ buf.writeDoubleBE(obj, 1)
+ } else {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xca
+ buf.writeFloatBE(obj, 1)
+ }
+
+ return buf
+}
+
+
+/***/ }),
+
+/***/ "../node_modules/msgpack5/lib/streams.js":
+/*!***********************************************!*\
+ !*** ../node_modules/msgpack5/lib/streams.js ***!
+ \***********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var Transform = __webpack_require__(/*! readable-stream */ "../node_modules/readable-stream/readable-browser.js").Transform
+var inherits = __webpack_require__(/*! inherits */ "../node_modules/inherits/inherits_browser.js")
+var bl = __webpack_require__(/*! bl */ "../node_modules/bl/bl.js")
+
+function Base (opts) {
+ opts = opts || {}
+
+ opts.objectMode = true
+ opts.highWaterMark = 16
+
+ Transform.call(this, opts)
+
+ this._msgpack = opts.msgpack
+}
+
+inherits(Base, Transform)
+
+function Encoder (opts) {
+ if (!(this instanceof Encoder)) {
+ opts = opts || {}
+ opts.msgpack = this
+ return new Encoder(opts)
+ }
+
+ Base.call(this, opts)
+ this._wrap = ('wrap' in opts) && opts.wrap
+}
+
+inherits(Encoder, Base)
+
+Encoder.prototype._transform = function (obj, enc, done) {
+ var buf = null
+
+ try {
+ buf = this._msgpack.encode(this._wrap ? obj.value : obj).slice(0)
+ } catch (err) {
+ this.emit('error', err)
+ return done()
+ }
+
+ this.push(buf)
+ done()
+}
+
+function Decoder (opts) {
+ if (!(this instanceof Decoder)) {
+ opts = opts || {}
+ opts.msgpack = this
+ return new Decoder(opts)
+ }
+
+ Base.call(this, opts)
+
+ this._chunks = bl()
+ this._wrap = ('wrap' in opts) && opts.wrap
+}
+
+inherits(Decoder, Base)
+
+Decoder.prototype._transform = function (buf, enc, done) {
+ if (buf) {
+ this._chunks.append(buf)
+ }
+
+ try {
+ var result = this._msgpack.decode(this._chunks)
+ if (this._wrap) {
+ result = {value: result}
+ }
+ this.push(result)
+ } catch (err) {
+ if (err instanceof this._msgpack.IncompleteBufferError) {
+ done()
+ } else {
+ this.emit('error', err)
+ }
+ return
+ }
+
+ if (this._chunks.length > 0) {
+ this._transform(null, enc, done)
+ } else {
+ done()
+ }
+}
+
+module.exports.decoder = Decoder
+module.exports.encoder = Encoder
+
+
+/***/ }),
+
+/***/ "../node_modules/process-nextick-args/index.js":
+/*!*****************************************************!*\
+ !*** ../node_modules/process-nextick-args/index.js ***!
+ \*****************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {
+
+if (!process.version ||
+ process.version.indexOf('v0.') === 0 ||
+ process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+ module.exports = { nextTick: nextTick };
+} else {
+ module.exports = process
+}
+
+function nextTick(fn, arg1, arg2, arg3) {
+ if (typeof fn !== 'function') {
+ throw new TypeError('"callback" argument must be a function');
+ }
+ var len = arguments.length;
+ var args, i;
+ switch (len) {
+ case 0:
+ case 1:
+ return process.nextTick(fn);
+ case 2:
+ return process.nextTick(function afterTickOne() {
+ fn.call(null, arg1);
+ });
+ case 3:
+ return process.nextTick(function afterTickTwo() {
+ fn.call(null, arg1, arg2);
+ });
+ case 4:
+ return process.nextTick(function afterTickThree() {
+ fn.call(null, arg1, arg2, arg3);
+ });
+ default:
+ args = new Array(len - 1);
+ i = 0;
+ while (i < args.length) {
+ args[i++] = arguments[i];
+ }
+ return process.nextTick(function afterTick() {
+ fn.apply(null, args);
+ });
+ }
+}
+
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../process/browser.js */ "../node_modules/process/browser.js")))
+
+/***/ }),
+
+/***/ "../node_modules/process/browser.js":
+/*!******************************************!*\
+ !*** ../node_modules/process/browser.js ***!
+ \******************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things. But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals. It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+ throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+ throw new Error('clearTimeout has not been defined');
+}
+(function () {
+ try {
+ if (typeof setTimeout === 'function') {
+ cachedSetTimeout = setTimeout;
+ } else {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ } catch (e) {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ try {
+ if (typeof clearTimeout === 'function') {
+ cachedClearTimeout = clearTimeout;
+ } else {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+ } catch (e) {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+} ())
+function runTimeout(fun) {
+ if (cachedSetTimeout === setTimeout) {
+ //normal enviroments in sane situations
+ return setTimeout(fun, 0);
+ }
+ // if setTimeout wasn't available but was latter defined
+ if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+ cachedSetTimeout = setTimeout;
+ return setTimeout(fun, 0);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedSetTimeout(fun, 0);
+ } catch(e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedSetTimeout.call(null, fun, 0);
+ } catch(e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+ return cachedSetTimeout.call(this, fun, 0);
+ }
+ }
+
+
+}
+function runClearTimeout(marker) {
+ if (cachedClearTimeout === clearTimeout) {
+ //normal enviroments in sane situations
+ return clearTimeout(marker);
+ }
+ // if clearTimeout wasn't available but was latter defined
+ if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+ cachedClearTimeout = clearTimeout;
+ return clearTimeout(marker);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedClearTimeout(marker);
+ } catch (e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedClearTimeout.call(null, marker);
+ } catch (e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+ // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+ return cachedClearTimeout.call(this, marker);
+ }
+ }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+ if (!draining || !currentQueue) {
+ return;
+ }
+ draining = false;
+ if (currentQueue.length) {
+ queue = currentQueue.concat(queue);
+ } else {
+ queueIndex = -1;
+ }
+ if (queue.length) {
+ drainQueue();
+ }
+}
+
+function drainQueue() {
+ if (draining) {
+ return;
+ }
+ var timeout = runTimeout(cleanUpNextTick);
+ draining = true;
+
+ var len = queue.length;
+ while(len) {
+ currentQueue = queue;
+ queue = [];
+ while (++queueIndex < len) {
+ if (currentQueue) {
+ currentQueue[queueIndex].run();
+ }
+ }
+ queueIndex = -1;
+ len = queue.length;
+ }
+ currentQueue = null;
+ draining = false;
+ runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+ var args = new Array(arguments.length - 1);
+ if (arguments.length > 1) {
+ for (var i = 1; i < arguments.length; i++) {
+ args[i - 1] = arguments[i];
+ }
+ }
+ queue.push(new Item(fun, args));
+ if (queue.length === 1 && !draining) {
+ runTimeout(drainQueue);
+ }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+ this.fun = fun;
+ this.array = array;
+}
+Item.prototype.run = function () {
+ this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+
+/***/ }),
+
+/***/ "../node_modules/readable-stream/lib/_stream_duplex.js":
+/*!*************************************************************!*\
+ !*** ../node_modules/readable-stream/lib/_stream_duplex.js ***!
+ \*************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+
+
+/**/
+
+var pna = __webpack_require__(/*! process-nextick-args */ "../node_modules/process-nextick-args/index.js");
+/**/
+
+/**/
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) {
+ keys.push(key);
+ }return keys;
+};
+/**/
+
+module.exports = Duplex;
+
+/**/
+var util = __webpack_require__(/*! core-util-is */ "../node_modules/core-util-is/lib/util.js");
+util.inherits = __webpack_require__(/*! inherits */ "../node_modules/inherits/inherits_browser.js");
+/**/
+
+var Readable = __webpack_require__(/*! ./_stream_readable */ "../node_modules/readable-stream/lib/_stream_readable.js");
+var Writable = __webpack_require__(/*! ./_stream_writable */ "../node_modules/readable-stream/lib/_stream_writable.js");
+
+util.inherits(Duplex, Readable);
+
+{
+ // avoid scope creep, the keys array can then be collected
+ var keys = objectKeys(Writable.prototype);
+ for (var v = 0; v < keys.length; v++) {
+ var method = keys[v];
+ if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+ }
+}
+
+function Duplex(options) {
+ if (!(this instanceof Duplex)) return new Duplex(options);
+
+ Readable.call(this, options);
+ Writable.call(this, options);
+
+ if (options && options.readable === false) this.readable = false;
+
+ if (options && options.writable === false) this.writable = false;
+
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
+
+ this.once('end', onend);
+}
+
+Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function () {
+ return this._writableState.highWaterMark;
+ }
+});
+
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended) return;
+
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ pna.nextTick(onEndNT, this);
+}
+
+function onEndNT(self) {
+ self.end();
+}
+
+Object.defineProperty(Duplex.prototype, 'destroyed', {
+ get: function () {
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return false;
+ }
+ return this._readableState.destroyed && this._writableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return;
+ }
+
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._readableState.destroyed = value;
+ this._writableState.destroyed = value;
+ }
+});
+
+Duplex.prototype._destroy = function (err, cb) {
+ this.push(null);
+ this.end();
+
+ pna.nextTick(cb, err);
+};
+
+/***/ }),
+
+/***/ "../node_modules/readable-stream/lib/_stream_passthrough.js":
+/*!******************************************************************!*\
+ !*** ../node_modules/readable-stream/lib/_stream_passthrough.js ***!
+ \******************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+
+
+module.exports = PassThrough;
+
+var Transform = __webpack_require__(/*! ./_stream_transform */ "../node_modules/readable-stream/lib/_stream_transform.js");
+
+/**/
+var util = __webpack_require__(/*! core-util-is */ "../node_modules/core-util-is/lib/util.js");
+util.inherits = __webpack_require__(/*! inherits */ "../node_modules/inherits/inherits_browser.js");
+/**/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough)) return new PassThrough(options);
+
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function (chunk, encoding, cb) {
+ cb(null, chunk);
+};
+
+/***/ }),
+
+/***/ "../node_modules/readable-stream/lib/_stream_readable.js":
+/*!***************************************************************!*\
+ !*** ../node_modules/readable-stream/lib/_stream_readable.js ***!
+ \***************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+
+
+/**/
+
+var pna = __webpack_require__(/*! process-nextick-args */ "../node_modules/process-nextick-args/index.js");
+/**/
+
+module.exports = Readable;
+
+/**/
+var isArray = __webpack_require__(/*! isarray */ "../node_modules/isarray/index.js");
+/**/
+
+/**/
+var Duplex;
+/**/
+
+Readable.ReadableState = ReadableState;
+
+/**/
+var EE = __webpack_require__(/*! events */ "../node_modules/events/events.js").EventEmitter;
+
+var EElistenerCount = function (emitter, type) {
+ return emitter.listeners(type).length;
+};
+/**/
+
+/**/
+var Stream = __webpack_require__(/*! ./internal/streams/stream */ "../node_modules/readable-stream/lib/internal/streams/stream-browser.js");
+/**/
+
+/**/
+
+var Buffer = __webpack_require__(/*! safe-buffer */ "../node_modules/safe-buffer/index.js").Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
+
+/**/
+
+/**/
+var util = __webpack_require__(/*! core-util-is */ "../node_modules/core-util-is/lib/util.js");
+util.inherits = __webpack_require__(/*! inherits */ "../node_modules/inherits/inherits_browser.js");
+/**/
+
+/**/
+var debugUtil = __webpack_require__(/*! util */ 0);
+var debug = void 0;
+if (debugUtil && debugUtil.debuglog) {
+ debug = debugUtil.debuglog('stream');
+} else {
+ debug = function () {};
+}
+/**/
+
+var BufferList = __webpack_require__(/*! ./internal/streams/BufferList */ "../node_modules/readable-stream/lib/internal/streams/BufferList.js");
+var destroyImpl = __webpack_require__(/*! ./internal/streams/destroy */ "../node_modules/readable-stream/lib/internal/streams/destroy.js");
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
+
+function prependListener(emitter, event, fn) {
+ // Sadly this is not cacheable as some libraries bundle their own
+ // event emitter implementation with them.
+ if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
+
+ // This is a hack to make sure that our error handler is attached before any
+ // userland ones. NEVER DO THIS. This is here only because this code needs
+ // to continue to work with older versions of Node.js that do not include
+ // the prependListener() method. The goal is to eventually remove this hack.
+ if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
+}
+
+function ReadableState(options, stream) {
+ Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ "../node_modules/readable-stream/lib/_stream_duplex.js");
+
+ options = options || {};
+
+ // Duplex streams are both readable and writable, but share
+ // the same options object.
+ // However, some cases require setting options to different
+ // values for the readable and the writable sides of the duplex stream.
+ // These options can be provided separately as readableXXX and writableXXX.
+ var isDuplex = stream instanceof Duplex;
+
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
+
+ if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ var readableHwm = options.readableHighWaterMark;
+ var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+
+ if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
+
+ // cast to ints.
+ this.highWaterMark = Math.floor(this.highWaterMark);
+
+ // A linked list is used to store data chunks instead of an array because the
+ // linked list can remove elements from the beginning faster than
+ // array.shift()
+ this.buffer = new BufferList();
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = null;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
+
+ // a flag to be able to tell if the event 'readable'/'data' is emitted
+ // immediately, or on a later tick. We set this to true at first, because
+ // any actions that shouldn't happen until "later" should generally also
+ // not happen before the first read call.
+ this.sync = true;
+
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+ this.resumeScheduled = false;
+
+ // has it been destroyed
+ this.destroyed = false;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
+
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
+
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder) StringDecoder = __webpack_require__(/*! string_decoder/ */ "../node_modules/string_decoder/lib/string_decoder.js").StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ "../node_modules/readable-stream/lib/_stream_duplex.js");
+
+ if (!(this instanceof Readable)) return new Readable(options);
+
+ this._readableState = new ReadableState(options, this);
+
+ // legacy
+ this.readable = true;
+
+ if (options) {
+ if (typeof options.read === 'function') this._read = options.read;
+
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+ }
+
+ Stream.call(this);
+}
+
+Object.defineProperty(Readable.prototype, 'destroyed', {
+ get: function () {
+ if (this._readableState === undefined) {
+ return false;
+ }
+ return this._readableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._readableState) {
+ return;
+ }
+
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._readableState.destroyed = value;
+ }
+});
+
+Readable.prototype.destroy = destroyImpl.destroy;
+Readable.prototype._undestroy = destroyImpl.undestroy;
+Readable.prototype._destroy = function (err, cb) {
+ this.push(null);
+ cb(err);
+};
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function (chunk, encoding) {
+ var state = this._readableState;
+ var skipChunkCheck;
+
+ if (!state.objectMode) {
+ if (typeof chunk === 'string') {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = Buffer.from(chunk, encoding);
+ encoding = '';
+ }
+ skipChunkCheck = true;
+ }
+ } else {
+ skipChunkCheck = true;
+ }
+
+ return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function (chunk) {
+ return readableAddChunk(this, chunk, null, true, false);
+};
+
+function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+ var state = stream._readableState;
+ if (chunk === null) {
+ state.reading = false;
+ onEofChunk(stream, state);
+ } else {
+ var er;
+ if (!skipChunkCheck) er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
+ chunk = _uint8ArrayToBuffer(chunk);
+ }
+
+ if (addToFront) {
+ if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
+ } else if (state.ended) {
+ stream.emit('error', new Error('stream.push() after EOF'));
+ } else {
+ state.reading = false;
+ if (state.decoder && !encoding) {
+ chunk = state.decoder.write(chunk);
+ if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
+ } else {
+ addChunk(stream, state, chunk, false);
+ }
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+ }
+
+ return needMoreData(state);
+}
+
+function addChunk(stream, state, chunk, addToFront) {
+ if (state.flowing && state.length === 0 && !state.sync) {
+ stream.emit('data', chunk);
+ stream.read(0);
+ } else {
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
+
+ if (state.needReadable) emitReadable(stream);
+ }
+ maybeReadMore(stream, state);
+}
+
+function chunkInvalid(state, chunk) {
+ var er;
+ if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
+}
+
+Readable.prototype.isPaused = function () {
+ return this._readableState.flowing === false;
+};
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function (enc) {
+ if (!StringDecoder) StringDecoder = __webpack_require__(/*! string_decoder/ */ "../node_modules/string_decoder/lib/string_decoder.js").StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+ return this;
+};
+
+// Don't raise the hwm > 8MB
+var MAX_HWM = 0x800000;
+function computeNewHighWaterMark(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2 to prevent increasing hwm excessively in
+ // tiny amounts
+ n--;
+ n |= n >>> 1;
+ n |= n >>> 2;
+ n |= n >>> 4;
+ n |= n >>> 8;
+ n |= n >>> 16;
+ n++;
+ }
+ return n;
+}
+
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function howMuchToRead(n, state) {
+ if (n <= 0 || state.length === 0 && state.ended) return 0;
+ if (state.objectMode) return 1;
+ if (n !== n) {
+ // Only flow one buffer at a time
+ if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
+ }
+ // If we're asking for more than the current hwm, then raise the hwm.
+ if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+ if (n <= state.length) return n;
+ // Don't have enough
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ }
+ return state.length;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function (n) {
+ debug('read', n);
+ n = parseInt(n, 10);
+ var state = this._readableState;
+ var nOrig = n;
+
+ if (n !== 0) state.emittedReadable = false;
+
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
+ debug('read: emitReadable', state.length, state.ended);
+ if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state);
+
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0) endReadable(this);
+ return null;
+ }
+
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+ debug('need readable', doRead);
+
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length === 0 || state.length - n < state.highWaterMark) {
+ doRead = true;
+ debug('length less than watermark', doRead);
+ }
+
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading) {
+ doRead = false;
+ debug('reading or ended', doRead);
+ } else if (doRead) {
+ debug('do read');
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0) state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ // If _read pushed data synchronously, then `reading` will be false,
+ // and we need to re-evaluate how much data we can return to the user.
+ if (!state.reading) n = howMuchToRead(nOrig, state);
+ }
+
+ var ret;
+ if (n > 0) ret = fromList(n, state);else ret = null;
+
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
+ } else {
+ state.length -= n;
+ }
+
+ if (state.length === 0) {
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (!state.ended) state.needReadable = true;
+
+ // If we tried to read() past the EOF, then emit end on the next tick.
+ if (nOrig !== n && state.ended) endReadable(this);
+ }
+
+ if (ret !== null) this.emit('data', ret);
+
+ return ret;
+};
+
+function onEofChunk(stream, state) {
+ if (state.ended) return;
+ if (state.decoder) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+ state.ended = true;
+
+ // emit 'readable' now to make sure it gets picked up.
+ emitReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (!state.emittedReadable) {
+ debug('emitReadable', state.flowing);
+ state.emittedReadable = true;
+ if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
+ }
+}
+
+function emitReadable_(stream) {
+ debug('emit readable');
+ stream.emit('readable');
+ flow(stream);
+}
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ pna.nextTick(maybeReadMore_, stream, state);
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
+ debug('maybeReadMore read 0');
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;else len = state.length;
+ }
+ state.readingMore = false;
+}
+
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function (n) {
+ this.emit('error', new Error('_read() is not implemented'));
+};
+
+Readable.prototype.pipe = function (dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+ state.pipesCount += 1;
+ debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
+
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+
+ var endFn = doEnd ? onend : unpipe;
+ if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
+
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable, unpipeInfo) {
+ debug('onunpipe');
+ if (readable === src) {
+ if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+ unpipeInfo.hasUnpiped = true;
+ cleanup();
+ }
+ }
+ }
+
+ function onend() {
+ debug('onend');
+ dest.end();
+ }
+
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+
+ var cleanedUp = false;
+ function cleanup() {
+ debug('cleanup');
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', unpipe);
+ src.removeListener('data', ondata);
+
+ cleanedUp = true;
+
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+ }
+
+ // If the user pushes more data while we're writing to dest then we'll end up
+ // in ondata again. However, we only want to increase awaitDrain once because
+ // dest will only emit one 'drain' event for the multiple writes.
+ // => Introduce a guard on increasing awaitDrain.
+ var increasedAwaitDrain = false;
+ src.on('data', ondata);
+ function ondata(chunk) {
+ debug('ondata');
+ increasedAwaitDrain = false;
+ var ret = dest.write(chunk);
+ if (false === ret && !increasedAwaitDrain) {
+ // If the user unpiped during `dest.write()`, it is possible
+ // to get stuck in a permanently paused state if that write
+ // also returned false.
+ // => Check whether `dest` is still a piping destination.
+ if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+ debug('false write response, pause', src._readableState.awaitDrain);
+ src._readableState.awaitDrain++;
+ increasedAwaitDrain = true;
+ }
+ src.pause();
+ }
+ }
+
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ function onerror(er) {
+ debug('onerror', er);
+ unpipe();
+ dest.removeListener('error', onerror);
+ if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
+ }
+
+ // Make sure our error handler is attached before userland ones.
+ prependListener(dest, 'error', onerror);
+
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ debug('onfinish');
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ debug('unpipe');
+ src.unpipe(dest);
+ }
+
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
+
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ debug('pipe resume');
+ src.resume();
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function () {
+ var state = src._readableState;
+ debug('pipeOnDrain', state.awaitDrain);
+ if (state.awaitDrain) state.awaitDrain--;
+ if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
+ state.flowing = true;
+ flow(src);
+ }
+ };
+}
+
+Readable.prototype.unpipe = function (dest) {
+ var state = this._readableState;
+ var unpipeInfo = { hasUnpiped: false };
+
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0) return this;
+
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes) return this;
+
+ if (!dest) dest = state.pipes;
+
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ state.flowing = false;
+ if (dest) dest.emit('unpipe', this, unpipeInfo);
+ return this;
+ }
+
+ // slow case. multiple pipe destinations.
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++) {
+ dests[i].emit('unpipe', this, unpipeInfo);
+ }return this;
+ }
+
+ // try to find the right one.
+ var index = indexOf(state.pipes, dest);
+ if (index === -1) return this;
+
+ state.pipes.splice(index, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1) state.pipes = state.pipes[0];
+
+ dest.emit('unpipe', this, unpipeInfo);
+
+ return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function (ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+
+ if (ev === 'data') {
+ // Start flowing on next tick if stream isn't explicitly paused
+ if (this._readableState.flowing !== false) this.resume();
+ } else if (ev === 'readable') {
+ var state = this._readableState;
+ if (!state.endEmitted && !state.readableListening) {
+ state.readableListening = state.needReadable = true;
+ state.emittedReadable = false;
+ if (!state.reading) {
+ pna.nextTick(nReadingNextTick, this);
+ } else if (state.length) {
+ emitReadable(this);
+ }
+ }
+ }
+
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+function nReadingNextTick(self) {
+ debug('readable nexttick read 0');
+ self.read(0);
+}
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function () {
+ var state = this._readableState;
+ if (!state.flowing) {
+ debug('resume');
+ state.flowing = true;
+ resume(this, state);
+ }
+ return this;
+};
+
+function resume(stream, state) {
+ if (!state.resumeScheduled) {
+ state.resumeScheduled = true;
+ pna.nextTick(resume_, stream, state);
+ }
+}
+
+function resume_(stream, state) {
+ if (!state.reading) {
+ debug('resume read 0');
+ stream.read(0);
+ }
+
+ state.resumeScheduled = false;
+ state.awaitDrain = 0;
+ stream.emit('resume');
+ flow(stream);
+ if (state.flowing && !state.reading) stream.read(0);
+}
+
+Readable.prototype.pause = function () {
+ debug('call pause flowing=%j', this._readableState.flowing);
+ if (false !== this._readableState.flowing) {
+ debug('pause');
+ this._readableState.flowing = false;
+ this.emit('pause');
+ }
+ return this;
+};
+
+function flow(stream) {
+ var state = stream._readableState;
+ debug('flow', state.flowing);
+ while (state.flowing && stream.read() !== null) {}
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function (stream) {
+ var _this = this;
+
+ var state = this._readableState;
+ var paused = false;
+
+ stream.on('end', function () {
+ debug('wrapped end');
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) _this.push(chunk);
+ }
+
+ _this.push(null);
+ });
+
+ stream.on('data', function (chunk) {
+ debug('wrapped data');
+ if (state.decoder) chunk = state.decoder.write(chunk);
+
+ // don't skip over falsy values in objectMode
+ if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
+
+ var ret = _this.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
+
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (this[i] === undefined && typeof stream[i] === 'function') {
+ this[i] = function (method) {
+ return function () {
+ return stream[method].apply(stream, arguments);
+ };
+ }(i);
+ }
+ }
+
+ // proxy certain important events.
+ for (var n = 0; n < kProxyEvents.length; n++) {
+ stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+ }
+
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ this._read = function (n) {
+ debug('wrapped _read', n);
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return this;
+};
+
+Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function () {
+ return this._readableState.highWaterMark;
+ }
+});
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromList(n, state) {
+ // nothing buffered
+ if (state.length === 0) return null;
+
+ var ret;
+ if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
+ // read it all, truncate the list
+ if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
+ state.buffer.clear();
+ } else {
+ // read part of list
+ ret = fromListPartial(n, state.buffer, state.decoder);
+ }
+
+ return ret;
+}
+
+// Extracts only enough buffered data to satisfy the amount requested.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromListPartial(n, list, hasStrings) {
+ var ret;
+ if (n < list.head.data.length) {
+ // slice is the same for buffers and strings
+ ret = list.head.data.slice(0, n);
+ list.head.data = list.head.data.slice(n);
+ } else if (n === list.head.data.length) {
+ // first chunk is a perfect match
+ ret = list.shift();
+ } else {
+ // result spans more than one buffer
+ ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
+ }
+ return ret;
+}
+
+// Copies a specified amount of characters from the list of buffered data
+// chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBufferString(n, list) {
+ var p = list.head;
+ var c = 1;
+ var ret = p.data;
+ n -= ret.length;
+ while (p = p.next) {
+ var str = p.data;
+ var nb = n > str.length ? str.length : n;
+ if (nb === str.length) ret += str;else ret += str.slice(0, n);
+ n -= nb;
+ if (n === 0) {
+ if (nb === str.length) {
+ ++c;
+ if (p.next) list.head = p.next;else list.head = list.tail = null;
+ } else {
+ list.head = p;
+ p.data = str.slice(nb);
+ }
+ break;
+ }
+ ++c;
+ }
+ list.length -= c;
+ return ret;
+}
+
+// Copies a specified amount of bytes from the list of buffered data chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBuffer(n, list) {
+ var ret = Buffer.allocUnsafe(n);
+ var p = list.head;
+ var c = 1;
+ p.data.copy(ret);
+ n -= p.data.length;
+ while (p = p.next) {
+ var buf = p.data;
+ var nb = n > buf.length ? buf.length : n;
+ buf.copy(ret, ret.length - n, 0, nb);
+ n -= nb;
+ if (n === 0) {
+ if (nb === buf.length) {
+ ++c;
+ if (p.next) list.head = p.next;else list.head = list.tail = null;
+ } else {
+ list.head = p;
+ p.data = buf.slice(nb);
+ }
+ break;
+ }
+ ++c;
+ }
+ list.length -= c;
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
+
+ if (!state.endEmitted) {
+ state.ended = true;
+ pna.nextTick(endReadableNT, state, stream);
+ }
+}
+
+function endReadableNT(state, stream) {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+}
+
+function indexOf(xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+ return -1;
+}
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "../node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../../process/browser.js */ "../node_modules/process/browser.js")))
+
+/***/ }),
+
+/***/ "../node_modules/readable-stream/lib/_stream_transform.js":
+/*!****************************************************************!*\
+ !*** ../node_modules/readable-stream/lib/_stream_transform.js ***!
+ \****************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+
+
+module.exports = Transform;
+
+var Duplex = __webpack_require__(/*! ./_stream_duplex */ "../node_modules/readable-stream/lib/_stream_duplex.js");
+
+/**/
+var util = __webpack_require__(/*! core-util-is */ "../node_modules/core-util-is/lib/util.js");
+util.inherits = __webpack_require__(/*! inherits */ "../node_modules/inherits/inherits_browser.js");
+/**/
+
+util.inherits(Transform, Duplex);
+
+function afterTransform(er, data) {
+ var ts = this._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb) {
+ return this.emit('error', new Error('write callback called multiple times'));
+ }
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data != null) // single equals check for both `null` and `undefined`
+ this.push(data);
+
+ cb(er);
+
+ var rs = this._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ this._read(rs.highWaterMark);
+ }
+}
+
+function Transform(options) {
+ if (!(this instanceof Transform)) return new Transform(options);
+
+ Duplex.call(this, options);
+
+ this._transformState = {
+ afterTransform: afterTransform.bind(this),
+ needTransform: false,
+ transforming: false,
+ writecb: null,
+ writechunk: null,
+ writeencoding: null
+ };
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ if (options) {
+ if (typeof options.transform === 'function') this._transform = options.transform;
+
+ if (typeof options.flush === 'function') this._flush = options.flush;
+ }
+
+ // When the writable side finishes, then flush out anything remaining.
+ this.on('prefinish', prefinish);
+}
+
+function prefinish() {
+ var _this = this;
+
+ if (typeof this._flush === 'function') {
+ this._flush(function (er, data) {
+ done(_this, er, data);
+ });
+ } else {
+ done(this, null, null);
+ }
+}
+
+Transform.prototype.push = function (chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function (chunk, encoding, cb) {
+ throw new Error('_transform() is not implemented');
+};
+
+Transform.prototype._write = function (chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function (n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+Transform.prototype._destroy = function (err, cb) {
+ var _this2 = this;
+
+ Duplex.prototype._destroy.call(this, err, function (err2) {
+ cb(err2);
+ _this2.emit('close');
+ });
+};
+
+function done(stream, er, data) {
+ if (er) return stream.emit('error', er);
+
+ if (data != null) // single equals check for both `null` and `undefined`
+ stream.push(data);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
+
+ if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
+
+ return stream.push(null);
+}
+
+/***/ }),
+
+/***/ "../node_modules/readable-stream/lib/_stream_writable.js":
+/*!***************************************************************!*\
+ !*** ../node_modules/readable-stream/lib/_stream_writable.js ***!
+ \***************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process, setImmediate, global) {// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+
+
+
+/**/
+
+var pna = __webpack_require__(/*! process-nextick-args */ "../node_modules/process-nextick-args/index.js");
+/**/
+
+module.exports = Writable;
+
+/* */
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+ this.next = null;
+}
+
+// It seems a linked list but it is not
+// there will be only 2 of these for each stream
+function CorkedRequest(state) {
+ var _this = this;
+
+ this.next = null;
+ this.entry = null;
+ this.finish = function () {
+ onCorkedFinish(_this, state);
+ };
+}
+/* */
+
+/**/
+var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
+/**/
+
+/**/
+var Duplex;
+/**/
+
+Writable.WritableState = WritableState;
+
+/**/
+var util = __webpack_require__(/*! core-util-is */ "../node_modules/core-util-is/lib/util.js");
+util.inherits = __webpack_require__(/*! inherits */ "../node_modules/inherits/inherits_browser.js");
+/**/
+
+/**/
+var internalUtil = {
+ deprecate: __webpack_require__(/*! util-deprecate */ "../node_modules/util-deprecate/browser.js")
+};
+/**/
+
+/**/
+var Stream = __webpack_require__(/*! ./internal/streams/stream */ "../node_modules/readable-stream/lib/internal/streams/stream-browser.js");
+/**/
+
+/**/
+
+var Buffer = __webpack_require__(/*! safe-buffer */ "../node_modules/safe-buffer/index.js").Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
+
+/**/
+
+var destroyImpl = __webpack_require__(/*! ./internal/streams/destroy */ "../node_modules/readable-stream/lib/internal/streams/destroy.js");
+
+util.inherits(Writable, Stream);
+
+function nop() {}
+
+function WritableState(options, stream) {
+ Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ "../node_modules/readable-stream/lib/_stream_duplex.js");
+
+ options = options || {};
+
+ // Duplex streams are both readable and writable, but share
+ // the same options object.
+ // However, some cases require setting options to different
+ // values for the readable and the writable sides of the duplex stream.
+ // These options can be provided separately as readableXXX and writableXXX.
+ var isDuplex = stream instanceof Duplex;
+
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
+
+ if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ var writableHwm = options.writableHighWaterMark;
+ var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+
+ if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
+
+ // cast to ints.
+ this.highWaterMark = Math.floor(this.highWaterMark);
+
+ // if _final has been called
+ this.finalCalled = false;
+
+ // drain event flag.
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
+
+ // has it been destroyed
+ this.destroyed = false;
+
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
+
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
+
+ // when true all writes will be buffered until .uncork() call
+ this.corked = 0;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, because any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
+
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function (er) {
+ onwrite(stream, er);
+ };
+
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
+
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
+
+ this.bufferedRequest = null;
+ this.lastBufferedRequest = null;
+
+ // number of pending user-supplied write callbacks
+ // this must be 0 before 'finish' can be emitted
+ this.pendingcb = 0;
+
+ // emit prefinish if the only thing we're waiting for is _write cbs
+ // This is relevant for synchronous Transform streams
+ this.prefinished = false;
+
+ // True if the error was already emitted and should not be thrown again
+ this.errorEmitted = false;
+
+ // count buffered requests
+ this.bufferedRequestCount = 0;
+
+ // allocate the first CorkedRequest, there is always
+ // one allocated and free to use, and we maintain at most two
+ this.corkedRequestsFree = new CorkedRequest(this);
+}
+
+WritableState.prototype.getBuffer = function getBuffer() {
+ var current = this.bufferedRequest;
+ var out = [];
+ while (current) {
+ out.push(current);
+ current = current.next;
+ }
+ return out;
+};
+
+(function () {
+ try {
+ Object.defineProperty(WritableState.prototype, 'buffer', {
+ get: internalUtil.deprecate(function () {
+ return this.getBuffer();
+ }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
+ });
+ } catch (_) {}
+})();
+
+// Test _writableState for inheritance to account for Duplex streams,
+// whose prototype chain only points to Readable.
+var realHasInstance;
+if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
+ realHasInstance = Function.prototype[Symbol.hasInstance];
+ Object.defineProperty(Writable, Symbol.hasInstance, {
+ value: function (object) {
+ if (realHasInstance.call(this, object)) return true;
+ if (this !== Writable) return false;
+
+ return object && object._writableState instanceof WritableState;
+ }
+ });
+} else {
+ realHasInstance = function (object) {
+ return object instanceof this;
+ };
+}
+
+function Writable(options) {
+ Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ "../node_modules/readable-stream/lib/_stream_duplex.js");
+
+ // Writable ctor is applied to Duplexes, too.
+ // `realHasInstance` is necessary because using plain `instanceof`
+ // would return false, as no `_writableState` property is attached.
+
+ // Trying to use the custom `instanceof` for Writable here will also break the
+ // Node.js LazyTransform implementation, which has a non-trivial getter for
+ // `_writableState` that would lead to infinite recursion.
+ if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
+ return new Writable(options);
+ }
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ if (options) {
+ if (typeof options.write === 'function') this._write = options.write;
+
+ if (typeof options.writev === 'function') this._writev = options.writev;
+
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+
+ if (typeof options.final === 'function') this._final = options.final;
+ }
+
+ Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function () {
+ this.emit('error', new Error('Cannot pipe, not readable'));
+};
+
+function writeAfterEnd(stream, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ pna.nextTick(cb, er);
+}
+
+// Checks that a user-supplied chunk is valid, especially for the particular
+// mode the stream is in. Currently this means that `null` is never accepted
+// and undefined/non-string values are only allowed in object mode.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ var er = false;
+
+ if (chunk === null) {
+ er = new TypeError('May not write null values to stream');
+ } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ if (er) {
+ stream.emit('error', er);
+ pna.nextTick(cb, er);
+ valid = false;
+ }
+ return valid;
+}
+
+Writable.prototype.write = function (chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+ var isBuf = !state.objectMode && _isUint8Array(chunk);
+
+ if (isBuf && !Buffer.isBuffer(chunk)) {
+ chunk = _uint8ArrayToBuffer(chunk);
+ }
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function') cb = nop;
+
+ if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
+ state.pendingcb++;
+ ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+ }
+
+ return ret;
+};
+
+Writable.prototype.cork = function () {
+ var state = this._writableState;
+
+ state.corked++;
+};
+
+Writable.prototype.uncork = function () {
+ var state = this._writableState;
+
+ if (state.corked) {
+ state.corked--;
+
+ if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+ }
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+ // node::ParseEncoding() requires lower case.
+ if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+ if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
+ this._writableState.defaultEncoding = encoding;
+ return this;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
+ chunk = Buffer.from(chunk, encoding);
+ }
+ return chunk;
+}
+
+Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function () {
+ return this._writableState.highWaterMark;
+ }
+});
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+ if (!isBuf) {
+ var newChunk = decodeChunk(state, chunk, encoding);
+ if (chunk !== newChunk) {
+ isBuf = true;
+ encoding = 'buffer';
+ chunk = newChunk;
+ }
+ }
+ var len = state.objectMode ? 1 : chunk.length;
+
+ state.length += len;
+
+ var ret = state.length < state.highWaterMark;
+ // we must ensure that previous needDrain will not be reset to false.
+ if (!ret) state.needDrain = true;
+
+ if (state.writing || state.corked) {
+ var last = state.lastBufferedRequest;
+ state.lastBufferedRequest = {
+ chunk: chunk,
+ encoding: encoding,
+ isBuf: isBuf,
+ callback: cb,
+ next: null
+ };
+ if (last) {
+ last.next = state.lastBufferedRequest;
+ } else {
+ state.bufferedRequest = state.lastBufferedRequest;
+ }
+ state.bufferedRequestCount += 1;
+ } else {
+ doWrite(stream, state, false, len, chunk, encoding, cb);
+ }
+
+ return ret;
+}
+
+function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ --state.pendingcb;
+
+ if (sync) {
+ // defer the callback if we are being called synchronously
+ // to avoid piling up things on the stack
+ pna.nextTick(cb, er);
+ // this can emit finish, and it will always happen
+ // after error
+ pna.nextTick(finishMaybe, stream, state);
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+ } else {
+ // the caller expect this to happen before if
+ // it is async
+ cb(er);
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+ // this can emit finish, but finish must
+ // always follow error
+ finishMaybe(stream, state);
+ }
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
+
+ if (er) onwriteError(stream, state, sync, er, cb);else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(state);
+
+ if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+ clearBuffer(stream, state);
+ }
+
+ if (sync) {
+ /**/
+ asyncWrite(afterWrite, stream, state, finished, cb);
+ /**/
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished) onwriteDrain(stream, state);
+ state.pendingcb--;
+ cb();
+ finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+}
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+ var entry = state.bufferedRequest;
+
+ if (stream._writev && entry && entry.next) {
+ // Fast case, write everything using _writev()
+ var l = state.bufferedRequestCount;
+ var buffer = new Array(l);
+ var holder = state.corkedRequestsFree;
+ holder.entry = entry;
+
+ var count = 0;
+ var allBuffers = true;
+ while (entry) {
+ buffer[count] = entry;
+ if (!entry.isBuf) allBuffers = false;
+ entry = entry.next;
+ count += 1;
+ }
+ buffer.allBuffers = allBuffers;
+
+ doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+
+ // doWrite is almost always async, defer these to save a bit of time
+ // as the hot path ends with doWrite
+ state.pendingcb++;
+ state.lastBufferedRequest = null;
+ if (holder.next) {
+ state.corkedRequestsFree = holder.next;
+ holder.next = null;
+ } else {
+ state.corkedRequestsFree = new CorkedRequest(state);
+ }
+ state.bufferedRequestCount = 0;
+ } else {
+ // Slow case, write chunks one-by-one
+ while (entry) {
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, false, len, chunk, encoding, cb);
+ entry = entry.next;
+ state.bufferedRequestCount--;
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ break;
+ }
+ }
+
+ if (entry === null) state.lastBufferedRequest = null;
+ }
+
+ state.bufferedRequest = entry;
+ state.bufferProcessing = false;
+}
+
+Writable.prototype._write = function (chunk, encoding, cb) {
+ cb(new Error('_write() is not implemented'));
+};
+
+Writable.prototype._writev = null;
+
+Writable.prototype.end = function (chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
+
+ // .end() fully uncorks
+ if (state.corked) {
+ state.corked = 1;
+ this.uncork();
+ }
+
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished) endWritable(this, state, cb);
+};
+
+function needFinish(state) {
+ return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+}
+function callFinal(stream, state) {
+ stream._final(function (err) {
+ state.pendingcb--;
+ if (err) {
+ stream.emit('error', err);
+ }
+ state.prefinished = true;
+ stream.emit('prefinish');
+ finishMaybe(stream, state);
+ });
+}
+function prefinish(stream, state) {
+ if (!state.prefinished && !state.finalCalled) {
+ if (typeof stream._final === 'function') {
+ state.pendingcb++;
+ state.finalCalled = true;
+ pna.nextTick(callFinal, stream, state);
+ } else {
+ state.prefinished = true;
+ stream.emit('prefinish');
+ }
+ }
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(state);
+ if (need) {
+ prefinish(stream, state);
+ if (state.pendingcb === 0) {
+ state.finished = true;
+ stream.emit('finish');
+ }
+ }
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
+ }
+ state.ended = true;
+ stream.writable = false;
+}
+
+function onCorkedFinish(corkReq, state, err) {
+ var entry = corkReq.entry;
+ corkReq.entry = null;
+ while (entry) {
+ var cb = entry.callback;
+ state.pendingcb--;
+ cb(err);
+ entry = entry.next;
+ }
+ if (state.corkedRequestsFree) {
+ state.corkedRequestsFree.next = corkReq;
+ } else {
+ state.corkedRequestsFree = corkReq;
+ }
+}
+
+Object.defineProperty(Writable.prototype, 'destroyed', {
+ get: function () {
+ if (this._writableState === undefined) {
+ return false;
+ }
+ return this._writableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._writableState) {
+ return;
+ }
+
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._writableState.destroyed = value;
+ }
+});
+
+Writable.prototype.destroy = destroyImpl.destroy;
+Writable.prototype._undestroy = destroyImpl.undestroy;
+Writable.prototype._destroy = function (err, cb) {
+ this.end();
+ cb(err);
+};
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../process/browser.js */ "../node_modules/process/browser.js"), __webpack_require__(/*! ./../../timers-browserify/main.js */ "../node_modules/timers-browserify/main.js").setImmediate, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "../node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
+/***/ "../node_modules/readable-stream/lib/internal/streams/BufferList.js":
+/*!**************************************************************************!*\
+ !*** ../node_modules/readable-stream/lib/internal/streams/BufferList.js ***!
+ \**************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Buffer = __webpack_require__(/*! safe-buffer */ "../node_modules/safe-buffer/index.js").Buffer;
+var util = __webpack_require__(/*! util */ 1);
+
+function copyBuffer(src, target, offset) {
+ src.copy(target, offset);
+}
+
+module.exports = function () {
+ function BufferList() {
+ _classCallCheck(this, BufferList);
+
+ this.head = null;
+ this.tail = null;
+ this.length = 0;
+ }
+
+ BufferList.prototype.push = function push(v) {
+ var entry = { data: v, next: null };
+ if (this.length > 0) this.tail.next = entry;else this.head = entry;
+ this.tail = entry;
+ ++this.length;
+ };
+
+ BufferList.prototype.unshift = function unshift(v) {
+ var entry = { data: v, next: this.head };
+ if (this.length === 0) this.tail = entry;
+ this.head = entry;
+ ++this.length;
+ };
+
+ BufferList.prototype.shift = function shift() {
+ if (this.length === 0) return;
+ var ret = this.head.data;
+ if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
+ --this.length;
+ return ret;
+ };
+
+ BufferList.prototype.clear = function clear() {
+ this.head = this.tail = null;
+ this.length = 0;
+ };
+
+ BufferList.prototype.join = function join(s) {
+ if (this.length === 0) return '';
+ var p = this.head;
+ var ret = '' + p.data;
+ while (p = p.next) {
+ ret += s + p.data;
+ }return ret;
+ };
+
+ BufferList.prototype.concat = function concat(n) {
+ if (this.length === 0) return Buffer.alloc(0);
+ if (this.length === 1) return this.head.data;
+ var ret = Buffer.allocUnsafe(n >>> 0);
+ var p = this.head;
+ var i = 0;
+ while (p) {
+ copyBuffer(p.data, ret, i);
+ i += p.data.length;
+ p = p.next;
+ }
+ return ret;
+ };
+
+ return BufferList;
+}();
+
+if (util && util.inspect && util.inspect.custom) {
+ module.exports.prototype[util.inspect.custom] = function () {
+ var obj = util.inspect({ length: this.length });
+ return this.constructor.name + ' ' + obj;
+ };
+}
+
+/***/ }),
+
+/***/ "../node_modules/readable-stream/lib/internal/streams/destroy.js":
+/*!***********************************************************************!*\
+ !*** ../node_modules/readable-stream/lib/internal/streams/destroy.js ***!
+ \***********************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/**/
+
+var pna = __webpack_require__(/*! process-nextick-args */ "../node_modules/process-nextick-args/index.js");
+/**/
+
+// undocumented cb() API, needed for core, not for public API
+function destroy(err, cb) {
+ var _this = this;
+
+ var readableDestroyed = this._readableState && this._readableState.destroyed;
+ var writableDestroyed = this._writableState && this._writableState.destroyed;
+
+ if (readableDestroyed || writableDestroyed) {
+ if (cb) {
+ cb(err);
+ } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
+ pna.nextTick(emitErrorNT, this, err);
+ }
+ return this;
+ }
+
+ // we set destroyed to true before firing error callbacks in order
+ // to make it re-entrance safe in case destroy() is called within callbacks
+
+ if (this._readableState) {
+ this._readableState.destroyed = true;
+ }
+
+ // if this is a duplex stream mark the writable part as destroyed as well
+ if (this._writableState) {
+ this._writableState.destroyed = true;
+ }
+
+ this._destroy(err || null, function (err) {
+ if (!cb && err) {
+ pna.nextTick(emitErrorNT, _this, err);
+ if (_this._writableState) {
+ _this._writableState.errorEmitted = true;
+ }
+ } else if (cb) {
+ cb(err);
+ }
+ });
+
+ return this;
+}
+
+function undestroy() {
+ if (this._readableState) {
+ this._readableState.destroyed = false;
+ this._readableState.reading = false;
+ this._readableState.ended = false;
+ this._readableState.endEmitted = false;
+ }
+
+ if (this._writableState) {
+ this._writableState.destroyed = false;
+ this._writableState.ended = false;
+ this._writableState.ending = false;
+ this._writableState.finished = false;
+ this._writableState.errorEmitted = false;
+ }
+}
+
+function emitErrorNT(self, err) {
+ self.emit('error', err);
+}
+
+module.exports = {
+ destroy: destroy,
+ undestroy: undestroy
+};
+
+/***/ }),
+
+/***/ "../node_modules/readable-stream/lib/internal/streams/stream-browser.js":
+/*!******************************************************************************!*\
+ !*** ../node_modules/readable-stream/lib/internal/streams/stream-browser.js ***!
+ \******************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(/*! events */ "../node_modules/events/events.js").EventEmitter;
+
+
+/***/ }),
+
+/***/ "../node_modules/readable-stream/readable-browser.js":
+/*!***********************************************************!*\
+ !*** ../node_modules/readable-stream/readable-browser.js ***!
+ \***********************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+exports = module.exports = __webpack_require__(/*! ./lib/_stream_readable.js */ "../node_modules/readable-stream/lib/_stream_readable.js");
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = __webpack_require__(/*! ./lib/_stream_writable.js */ "../node_modules/readable-stream/lib/_stream_writable.js");
+exports.Duplex = __webpack_require__(/*! ./lib/_stream_duplex.js */ "../node_modules/readable-stream/lib/_stream_duplex.js");
+exports.Transform = __webpack_require__(/*! ./lib/_stream_transform.js */ "../node_modules/readable-stream/lib/_stream_transform.js");
+exports.PassThrough = __webpack_require__(/*! ./lib/_stream_passthrough.js */ "../node_modules/readable-stream/lib/_stream_passthrough.js");
+
+
+/***/ }),
+
+/***/ "../node_modules/safe-buffer/index.js":
+/*!********************************************!*\
+ !*** ../node_modules/safe-buffer/index.js ***!
+ \********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* eslint-disable node/no-deprecated-api */
+var buffer = __webpack_require__(/*! buffer */ "../node_modules/buffer/index.js")
+var Buffer = buffer.Buffer
+
+// alternative to using Object.keys for old browsers
+function copyProps (src, dst) {
+ for (var key in src) {
+ dst[key] = src[key]
+ }
+}
+if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+ module.exports = buffer
+} else {
+ // Copy properties from require('buffer')
+ copyProps(buffer, exports)
+ exports.Buffer = SafeBuffer
+}
+
+function SafeBuffer (arg, encodingOrOffset, length) {
+ return Buffer(arg, encodingOrOffset, length)
+}
+
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
+
+SafeBuffer.from = function (arg, encodingOrOffset, length) {
+ if (typeof arg === 'number') {
+ throw new TypeError('Argument must not be a number')
+ }
+ return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.alloc = function (size, fill, encoding) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ var buf = Buffer(size)
+ if (fill !== undefined) {
+ if (typeof encoding === 'string') {
+ buf.fill(fill, encoding)
+ } else {
+ buf.fill(fill)
+ }
+ } else {
+ buf.fill(0)
+ }
+ return buf
+}
+
+SafeBuffer.allocUnsafe = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return Buffer(size)
+}
+
+SafeBuffer.allocUnsafeSlow = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return buffer.SlowBuffer(size)
+}
+
+
+/***/ }),
+
+/***/ "../node_modules/setimmediate/setImmediate.js":
+/*!****************************************************!*\
+ !*** ../node_modules/setimmediate/setImmediate.js ***!
+ \****************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
+ "use strict";
+
+ if (global.setImmediate) {
+ return;
+ }
+
+ var nextHandle = 1; // Spec says greater than zero
+ var tasksByHandle = {};
+ var currentlyRunningATask = false;
+ var doc = global.document;
+ var registerImmediate;
+
+ function setImmediate(callback) {
+ // Callback can either be a function or a string
+ if (typeof callback !== "function") {
+ callback = new Function("" + callback);
+ }
+ // Copy function arguments
+ var args = new Array(arguments.length - 1);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i + 1];
+ }
+ // Store and register the task
+ var task = { callback: callback, args: args };
+ tasksByHandle[nextHandle] = task;
+ registerImmediate(nextHandle);
+ return nextHandle++;
+ }
+
+ function clearImmediate(handle) {
+ delete tasksByHandle[handle];
+ }
+
+ function run(task) {
+ var callback = task.callback;
+ var args = task.args;
+ switch (args.length) {
+ case 0:
+ callback();
+ break;
+ case 1:
+ callback(args[0]);
+ break;
+ case 2:
+ callback(args[0], args[1]);
+ break;
+ case 3:
+ callback(args[0], args[1], args[2]);
+ break;
+ default:
+ callback.apply(undefined, args);
+ break;
+ }
+ }
+
+ function runIfPresent(handle) {
+ // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
+ // So if we're currently running a task, we'll need to delay this invocation.
+ if (currentlyRunningATask) {
+ // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
+ // "too much recursion" error.
+ setTimeout(runIfPresent, 0, handle);
+ } else {
+ var task = tasksByHandle[handle];
+ if (task) {
+ currentlyRunningATask = true;
+ try {
+ run(task);
+ } finally {
+ clearImmediate(handle);
+ currentlyRunningATask = false;
+ }
+ }
+ }
+ }
+
+ function installNextTickImplementation() {
+ registerImmediate = function(handle) {
+ process.nextTick(function () { runIfPresent(handle); });
+ };
+ }
+
+ function canUsePostMessage() {
+ // The test against `importScripts` prevents this implementation from being installed inside a web worker,
+ // where `global.postMessage` means something completely different and can't be used for this purpose.
+ if (global.postMessage && !global.importScripts) {
+ var postMessageIsAsynchronous = true;
+ var oldOnMessage = global.onmessage;
+ global.onmessage = function() {
+ postMessageIsAsynchronous = false;
+ };
+ global.postMessage("", "*");
+ global.onmessage = oldOnMessage;
+ return postMessageIsAsynchronous;
+ }
+ }
+
+ function installPostMessageImplementation() {
+ // Installs an event handler on `global` for the `message` event: see
+ // * https://developer.mozilla.org/en/DOM/window.postMessage
+ // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
+
+ var messagePrefix = "setImmediate$" + Math.random() + "$";
+ var onGlobalMessage = function(event) {
+ if (event.source === global &&
+ typeof event.data === "string" &&
+ event.data.indexOf(messagePrefix) === 0) {
+ runIfPresent(+event.data.slice(messagePrefix.length));
+ }
+ };
+
+ if (global.addEventListener) {
+ global.addEventListener("message", onGlobalMessage, false);
+ } else {
+ global.attachEvent("onmessage", onGlobalMessage);
+ }
+
+ registerImmediate = function(handle) {
+ global.postMessage(messagePrefix + handle, "*");
+ };
+ }
+
+ function installMessageChannelImplementation() {
+ var channel = new MessageChannel();
+ channel.port1.onmessage = function(event) {
+ var handle = event.data;
+ runIfPresent(handle);
+ };
+
+ registerImmediate = function(handle) {
+ channel.port2.postMessage(handle);
+ };
+ }
+
+ function installReadyStateChangeImplementation() {
+ var html = doc.documentElement;
+ registerImmediate = function(handle) {
+ // Create a
+function shouldAutoStart() {
+ return document &&
+ document.currentScript &&
+ document.currentScript.getAttribute('autostart') !== 'false';
+}
+exports.shouldAutoStart = shouldAutoStart;
+
+
+/***/ }),
+
+/***/ "./Environment.ts":
+/*!************************!*\
+ !*** ./Environment.ts ***!
+ \************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+function setPlatform(platformInstance) {
+ exports.platform = platformInstance;
+ return exports.platform;
+}
+exports.setPlatform = setPlatform;
+
+
+/***/ }),
+
+/***/ "./GlobalExports.ts":
+/*!**************************!*\
+ !*** ./GlobalExports.ts ***!
+ \**************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var UriHelper_1 = __webpack_require__(/*! ./Services/UriHelper */ "./Services/UriHelper.ts");
+var Http_1 = __webpack_require__(/*! ./Services/Http */ "./Services/Http.ts");
+var Renderer_1 = __webpack_require__(/*! ./Rendering/Renderer */ "./Rendering/Renderer.ts");
+// Make the following APIs available in global scope for invocation from JS
+window['Blazor'] = {
+ navigateTo: UriHelper_1.navigateTo,
+ _internal: {
+ attachRootComponentToElement: Renderer_1.attachRootComponentToElement,
+ http: Http_1.internalFunctions,
+ uriHelper: UriHelper_1.internalFunctions,
+ },
+};
+
+
+/***/ }),
+
+/***/ "./Platform/Circuits/AutoReconnectCircuitHandler.ts":
+/*!**********************************************************!*\
+ !*** ./Platform/Circuits/AutoReconnectCircuitHandler.ts ***!
+ \**********************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ 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) : new P(function (resolve) { resolve(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 (_) 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 UserSpecifiedDisplay_1 = __webpack_require__(/*! ./UserSpecifiedDisplay */ "./Platform/Circuits/UserSpecifiedDisplay.ts");
+var DefaultReconnectDisplay_1 = __webpack_require__(/*! ./DefaultReconnectDisplay */ "./Platform/Circuits/DefaultReconnectDisplay.ts");
+var ILogger_1 = __webpack_require__(/*! ../Logging/ILogger */ "./Platform/Logging/ILogger.ts");
+var AutoReconnectCircuitHandler = /** @class */ (function () {
+ function AutoReconnectCircuitHandler(logger) {
+ var _this = this;
+ this.logger = logger;
+ this.reconnectDisplay = new DefaultReconnectDisplay_1.DefaultReconnectDisplay(document);
+ document.addEventListener('DOMContentLoaded', function () {
+ var modal = document.getElementById(AutoReconnectCircuitHandler.DialogId);
+ if (modal) {
+ _this.reconnectDisplay = new UserSpecifiedDisplay_1.UserSpecifiedDisplay(modal);
+ }
+ });
+ }
+ AutoReconnectCircuitHandler.prototype.onConnectionUp = function () {
+ this.reconnectDisplay.hide();
+ };
+ AutoReconnectCircuitHandler.prototype.delay = function () {
+ return new Promise(function (resolve) { return setTimeout(resolve, AutoReconnectCircuitHandler.RetryInterval); });
+ };
+ AutoReconnectCircuitHandler.prototype.onConnectionDown = function () {
+ return __awaiter(this, void 0, void 0, function () {
+ var i, result, err_1;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ this.reconnectDisplay.show();
+ i = 0;
+ _a.label = 1;
+ case 1:
+ if (!(i < AutoReconnectCircuitHandler.MaxRetries)) return [3 /*break*/, 7];
+ return [4 /*yield*/, this.delay()];
+ case 2:
+ _a.sent();
+ _a.label = 3;
+ case 3:
+ _a.trys.push([3, 5, , 6]);
+ return [4 /*yield*/, window['Blazor'].reconnect()];
+ case 4:
+ result = _a.sent();
+ if (!result) {
+ // If the server responded and refused to reconnect, stop auto-retrying.
+ return [3 /*break*/, 7];
+ }
+ return [2 /*return*/];
+ case 5:
+ err_1 = _a.sent();
+ this.logger.log(ILogger_1.LogLevel.Error, err_1);
+ return [3 /*break*/, 6];
+ case 6:
+ i++;
+ return [3 /*break*/, 1];
+ case 7:
+ this.reconnectDisplay.failed();
+ return [2 /*return*/];
+ }
+ });
+ });
+ };
+ AutoReconnectCircuitHandler.MaxRetries = 5;
+ AutoReconnectCircuitHandler.RetryInterval = 3000;
+ AutoReconnectCircuitHandler.DialogId = 'components-reconnect-modal';
+ return AutoReconnectCircuitHandler;
+}());
+exports.AutoReconnectCircuitHandler = AutoReconnectCircuitHandler;
+
+
+/***/ }),
+
+/***/ "./Platform/Circuits/CircuitManager.ts":
+/*!*********************************************!*\
+ !*** ./Platform/Circuits/CircuitManager.ts ***!
+ \*********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ 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) : new P(function (resolve) { resolve(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 (_) 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 __values = (this && this.__values) || function (o) {
+ var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+ if (m) return m.call(o);
+ return {
+ next: function () {
+ if (o && i >= o.length) o = void 0;
+ return { value: o && o[i++], done: !o };
+ }
+ };
+};
+var __read = (this && this.__read) || function (o, n) {
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
+ if (!m) return o;
+ var i = m.call(o), r, ar = [], e;
+ try {
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+ }
+ catch (error) { e = { error: error }; }
+ finally {
+ try {
+ if (r && !r.done && (m = i["return"])) m.call(i);
+ }
+ finally { if (e) throw e.error; }
+ }
+ return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var UriHelper_1 = __webpack_require__(/*! ../../Services/UriHelper */ "./Services/UriHelper.ts");
+var ComponentDescriptor_1 = __webpack_require__(/*! ./ComponentDescriptor */ "./Platform/Circuits/ComponentDescriptor.ts");
+var CircuitDescriptor = /** @class */ (function () {
+ function CircuitDescriptor(circuitId, components) {
+ this.circuitId = circuitId;
+ this.components = components;
+ }
+ CircuitDescriptor.prototype.reconnect = function (reconnection) {
+ return reconnection.invoke('ConnectCircuit', this.circuitId);
+ };
+ return CircuitDescriptor;
+}());
+exports.CircuitDescriptor = CircuitDescriptor;
+function discoverPrerenderedCircuits(document) {
+ var e_1, _a;
+ var commentPairs = resolveCommentPairs(document);
+ var discoveredCircuits = new Map();
+ for (var i = 0; i < commentPairs.length; i++) {
+ var pair = commentPairs[i];
+ var circuit = discoveredCircuits.get(pair.start.circuitId);
+ if (!circuit) {
+ circuit = [];
+ discoveredCircuits.set(pair.start.circuitId, circuit);
+ }
+ var entry = new ComponentDescriptor_1.ComponentDescriptor(pair.start.componentId, pair.start.circuitId, pair.start.rendererId, pair);
+ circuit.push(entry);
+ }
+ var circuits = [];
+ try {
+ for (var discoveredCircuits_1 = __values(discoveredCircuits), discoveredCircuits_1_1 = discoveredCircuits_1.next(); !discoveredCircuits_1_1.done; discoveredCircuits_1_1 = discoveredCircuits_1.next()) {
+ var _b = __read(discoveredCircuits_1_1.value, 2), key = _b[0], values = _b[1];
+ circuits.push(new CircuitDescriptor(key, values));
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (discoveredCircuits_1_1 && !discoveredCircuits_1_1.done && (_a = discoveredCircuits_1.return)) _a.call(discoveredCircuits_1);
+ }
+ finally { if (e_1) throw e_1.error; }
+ }
+ return circuits;
+}
+exports.discoverPrerenderedCircuits = discoverPrerenderedCircuits;
+function startCircuit(connection) {
+ return __awaiter(this, void 0, void 0, function () {
+ var result;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0: return [4 /*yield*/, connection.invoke('StartCircuit', UriHelper_1.internalFunctions.getLocationHref(), UriHelper_1.internalFunctions.getBaseURI())];
+ case 1:
+ result = _a.sent();
+ if (result) {
+ return [2 /*return*/, new CircuitDescriptor(result, [])];
+ }
+ else {
+ return [2 /*return*/, undefined];
+ }
+ return [2 /*return*/];
+ }
+ });
+ });
+}
+exports.startCircuit = startCircuit;
+function resolveCommentPairs(node) {
+ if (!node.hasChildNodes()) {
+ return [];
+ }
+ var result = [];
+ var children = node.childNodes;
+ var i = 0;
+ var childrenLength = children.length;
+ while (i < childrenLength) {
+ var currentChildNode = children[i];
+ var startComponent = getComponentStartComment(currentChildNode);
+ if (!startComponent) {
+ i++;
+ var childResults = resolveCommentPairs(currentChildNode);
+ for (var j = 0; j < childResults.length; j++) {
+ var childResult = childResults[j];
+ result.push(childResult);
+ }
+ continue;
+ }
+ var endComponent = getComponentEndComment(startComponent, children, i + 1, childrenLength);
+ result.push({ start: startComponent, end: endComponent });
+ i = endComponent.index + 1;
+ }
+ return result;
+}
+function getComponentStartComment(node) {
+ if (node.nodeType !== Node.COMMENT_NODE) {
+ return;
+ }
+ if (node.textContent) {
+ var componentStartComment = /\W+M.A.C.Component:[^{]*(.*)$/;
+ var definition = componentStartComment.exec(node.textContent);
+ var json = definition && definition[1];
+ if (json) {
+ try {
+ var _a = JSON.parse(json), componentId = _a.componentId, circuitId = _a.circuitId, rendererId = _a.rendererId;
+ var allComponents = !!componentId && !!circuitId && !!rendererId;
+ if (allComponents) {
+ return {
+ node: node,
+ circuitId: circuitId,
+ rendererId: Number.parseInt(rendererId),
+ componentId: Number.parseInt(componentId),
+ };
+ }
+ else {
+ throw new Error("Found malformed start component comment at " + node.textContent);
+ }
+ }
+ catch (error) {
+ throw new Error("Found malformed start component comment at " + node.textContent);
+ }
+ }
+ }
+}
+function getComponentEndComment(component, children, index, end) {
+ for (var i = index; i < end; i++) {
+ var node = children[i];
+ if (node.nodeType !== Node.COMMENT_NODE) {
+ continue;
+ }
+ if (!node.textContent) {
+ continue;
+ }
+ var componentEndComment = /\W+M.A.C.Component:\W+(\d+)\W+$/;
+ var definition = componentEndComment.exec(node.textContent);
+ var rawComponentId = definition && definition[1];
+ if (!rawComponentId) {
+ continue;
+ }
+ try {
+ var componentId = Number.parseInt(rawComponentId);
+ if (componentId === component.componentId) {
+ return { componentId: componentId, node: node, index: i };
+ }
+ else {
+ throw new Error("Found malformed end component comment at " + node.textContent);
+ }
+ }
+ catch (error) {
+ throw new Error("Found malformed end component comment at " + node.textContent);
+ }
+ }
+ throw new Error("End component comment not found for " + component.node);
+}
+
+
+/***/ }),
+
+/***/ "./Platform/Circuits/ComponentDescriptor.ts":
+/*!**************************************************!*\
+ !*** ./Platform/Circuits/ComponentDescriptor.ts ***!
+ \**************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var Renderer_1 = __webpack_require__(/*! ../../Rendering/Renderer */ "./Rendering/Renderer.ts");
+var LogicalElements_1 = __webpack_require__(/*! ../../Rendering/LogicalElements */ "./Rendering/LogicalElements.ts");
+var ComponentDescriptor = /** @class */ (function () {
+ function ComponentDescriptor(componentId, circuitId, rendererId, descriptor) {
+ this.componentId = componentId;
+ this.circuitId = circuitId;
+ this.rendererId = rendererId;
+ this.registrationTags = descriptor;
+ }
+ ComponentDescriptor.prototype.initialize = function () {
+ var startEndPair = { start: this.registrationTags.start.node, end: this.registrationTags.end.node };
+ var logicalElement = LogicalElements_1.toLogicalRootCommentElement(startEndPair.start, startEndPair.end);
+ Renderer_1.attachRootComponentToLogicalElement(this.rendererId, logicalElement, this.componentId);
+ };
+ return ComponentDescriptor;
+}());
+exports.ComponentDescriptor = ComponentDescriptor;
+
+
+/***/ }),
+
+/***/ "./Platform/Circuits/DefaultReconnectDisplay.ts":
+/*!******************************************************!*\
+ !*** ./Platform/Circuits/DefaultReconnectDisplay.ts ***!
+ \******************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var AutoReconnectCircuitHandler_1 = __webpack_require__(/*! ./AutoReconnectCircuitHandler */ "./Platform/Circuits/AutoReconnectCircuitHandler.ts");
+var DefaultReconnectDisplay = /** @class */ (function () {
+ function DefaultReconnectDisplay(document) {
+ this.document = document;
+ this.addedToDom = false;
+ this.modal = this.document.createElement('div');
+ this.modal.id = AutoReconnectCircuitHandler_1.AutoReconnectCircuitHandler.DialogId;
+ var modalStyles = [
+ 'position: fixed',
+ 'top: 0',
+ 'right: 0',
+ 'bottom: 0',
+ 'left: 0',
+ 'z-index: 1000',
+ 'display: none',
+ 'overflow: hidden',
+ 'background-color: #fff',
+ 'opacity: 0.8',
+ 'text-align: center',
+ 'font-weight: bold',
+ ];
+ this.modal.style.cssText = modalStyles.join(';');
+ this.modal.innerHTML = '';
+ this.message = this.modal.querySelector('h5');
+ this.button = this.modal.querySelector('button');
+ this.button.addEventListener('click', function () { return window['Blazor'].reconnect(); });
+ }
+ DefaultReconnectDisplay.prototype.show = function () {
+ if (!this.addedToDom) {
+ this.addedToDom = true;
+ this.document.body.appendChild(this.modal);
+ }
+ this.modal.style.display = 'block';
+ this.button.style.display = 'none';
+ this.message.textContent = 'Attempting to reconnect to the server...';
+ };
+ DefaultReconnectDisplay.prototype.hide = function () {
+ this.modal.style.display = 'none';
+ };
+ DefaultReconnectDisplay.prototype.failed = function () {
+ this.button.style.display = 'block';
+ this.message.textContent = 'Failed to reconnect to the server.';
+ };
+ return DefaultReconnectDisplay;
+}());
+exports.DefaultReconnectDisplay = DefaultReconnectDisplay;
+
+
+/***/ }),
+
+/***/ "./Platform/Circuits/RenderQueue.ts":
+/*!******************************************!*\
+ !*** ./Platform/Circuits/RenderQueue.ts ***!
+ \******************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ 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) : new P(function (resolve) { resolve(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 (_) 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 Renderer_1 = __webpack_require__(/*! ../../Rendering/Renderer */ "./Rendering/Renderer.ts");
+var OutOfProcessRenderBatch_1 = __webpack_require__(/*! ../../Rendering/RenderBatch/OutOfProcessRenderBatch */ "./Rendering/RenderBatch/OutOfProcessRenderBatch.ts");
+var ILogger_1 = __webpack_require__(/*! ../Logging/ILogger */ "./Platform/Logging/ILogger.ts");
+var RenderQueue = /** @class */ (function () {
+ function RenderQueue(browserRendererId, logger) {
+ this.nextBatchId = 2;
+ this.browserRendererId = browserRendererId;
+ this.logger = logger;
+ }
+ RenderQueue.getOrCreateQueue = function (browserRendererId, logger) {
+ var queue = this.renderQueues.get(browserRendererId);
+ if (queue) {
+ return queue;
+ }
+ var newQueue = new RenderQueue(browserRendererId, logger);
+ this.renderQueues.set(browserRendererId, newQueue);
+ return newQueue;
+ };
+ RenderQueue.prototype.processBatch = function (receivedBatchId, batchData, connection) {
+ if (receivedBatchId < this.nextBatchId) {
+ this.logger.log(ILogger_1.LogLevel.Debug, "Batch " + receivedBatchId + " already processed. Waiting for batch " + this.nextBatchId + ".");
+ return;
+ }
+ if (receivedBatchId > this.nextBatchId) {
+ this.logger.log(ILogger_1.LogLevel.Debug, "Waiting for batch " + this.nextBatchId + ". Batch " + receivedBatchId + " not processed.");
+ return;
+ }
+ try {
+ this.nextBatchId++;
+ this.logger.log(ILogger_1.LogLevel.Debug, "Applying batch " + receivedBatchId + ".");
+ Renderer_1.renderBatch(this.browserRendererId, new OutOfProcessRenderBatch_1.OutOfProcessRenderBatch(batchData));
+ this.completeBatch(connection, receivedBatchId);
+ }
+ catch (error) {
+ this.logger.log(ILogger_1.LogLevel.Error, "There was an error applying batch " + receivedBatchId + ".");
+ // If there's a rendering exception, notify server *and* throw on client
+ connection.send('OnRenderCompleted', receivedBatchId, error.toString());
+ throw error;
+ }
+ };
+ RenderQueue.prototype.getLastBatchid = function () {
+ return this.nextBatchId - 1;
+ };
+ RenderQueue.prototype.completeBatch = function (connection, batchId) {
+ return __awaiter(this, void 0, void 0, function () {
+ var _a;
+ return __generator(this, function (_b) {
+ switch (_b.label) {
+ case 0:
+ _b.trys.push([0, 2, , 3]);
+ return [4 /*yield*/, connection.send('OnRenderCompleted', batchId, null)];
+ case 1:
+ _b.sent();
+ return [3 /*break*/, 3];
+ case 2:
+ _a = _b.sent();
+ this.logger.log(ILogger_1.LogLevel.Warning, "Failed to deliver completion notification for render '" + batchId + "'.");
+ return [3 /*break*/, 3];
+ case 3: return [2 /*return*/];
+ }
+ });
+ });
+ };
+ RenderQueue.renderQueues = new Map();
+ return RenderQueue;
+}());
+exports.default = RenderQueue;
+
+
+/***/ }),
+
+/***/ "./Platform/Circuits/UserSpecifiedDisplay.ts":
+/*!***************************************************!*\
+ !*** ./Platform/Circuits/UserSpecifiedDisplay.ts ***!
+ \***************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var UserSpecifiedDisplay = /** @class */ (function () {
+ function UserSpecifiedDisplay(dialog) {
+ this.dialog = dialog;
+ }
+ UserSpecifiedDisplay.prototype.show = function () {
+ this.removeClasses();
+ this.dialog.classList.add(UserSpecifiedDisplay.ShowClassName);
+ };
+ UserSpecifiedDisplay.prototype.hide = function () {
+ this.removeClasses();
+ this.dialog.classList.add(UserSpecifiedDisplay.HideClassName);
+ };
+ UserSpecifiedDisplay.prototype.failed = function () {
+ this.removeClasses();
+ this.dialog.classList.add(UserSpecifiedDisplay.FailedClassName);
+ };
+ UserSpecifiedDisplay.prototype.removeClasses = function () {
+ this.dialog.classList.remove(UserSpecifiedDisplay.ShowClassName, UserSpecifiedDisplay.HideClassName, UserSpecifiedDisplay.FailedClassName);
+ };
+ UserSpecifiedDisplay.ShowClassName = 'components-reconnect-show';
+ UserSpecifiedDisplay.HideClassName = 'components-reconnect-hide';
+ UserSpecifiedDisplay.FailedClassName = 'components-reconnect-failed';
+ return UserSpecifiedDisplay;
+}());
+exports.UserSpecifiedDisplay = UserSpecifiedDisplay;
+
+
+/***/ }),
+
+/***/ "./Platform/Logging/ILogger.ts":
+/*!*************************************!*\
+ !*** ./Platform/Logging/ILogger.ts ***!
+ \*************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+// These values are designed to match the ASP.NET Log Levels since that's the pattern we're emulating here.
+/** Indicates the severity of a log message.
+ *
+ * Log Levels are ordered in increasing severity. So `Debug` is more severe than `Trace`, etc.
+ */
+var LogLevel;
+(function (LogLevel) {
+ /** Log level for very low severity diagnostic messages. */
+ LogLevel[LogLevel["Trace"] = 0] = "Trace";
+ /** Log level for low severity diagnostic messages. */
+ LogLevel[LogLevel["Debug"] = 1] = "Debug";
+ /** Log level for informational diagnostic messages. */
+ LogLevel[LogLevel["Information"] = 2] = "Information";
+ /** Log level for diagnostic messages that indicate a non-fatal problem. */
+ LogLevel[LogLevel["Warning"] = 3] = "Warning";
+ /** Log level for diagnostic messages that indicate a failure in the current operation. */
+ LogLevel[LogLevel["Error"] = 4] = "Error";
+ /** Log level for diagnostic messages that indicate a failure that will terminate the entire application. */
+ LogLevel[LogLevel["Critical"] = 5] = "Critical";
+ /** The highest possible log level. Used when configuring logging to indicate that no log messages should be emitted. */
+ LogLevel[LogLevel["None"] = 6] = "None";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+
+
+/***/ }),
+
+/***/ "./Platform/Logging/Loggers.ts":
+/*!*************************************!*\
+ !*** ./Platform/Logging/Loggers.ts ***!
+ \*************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+/* eslint-disable no-console */
+Object.defineProperty(exports, "__esModule", { value: true });
+var ILogger_1 = __webpack_require__(/*! ./ILogger */ "./Platform/Logging/ILogger.ts");
+var NullLogger = /** @class */ (function () {
+ function NullLogger() {
+ }
+ NullLogger.prototype.log = function (_logLevel, _message) {
+ };
+ NullLogger.instance = new NullLogger();
+ return NullLogger;
+}());
+exports.NullLogger = NullLogger;
+var ConsoleLogger = /** @class */ (function () {
+ function ConsoleLogger(minimumLogLevel) {
+ this.minimumLogLevel = minimumLogLevel;
+ }
+ ConsoleLogger.prototype.log = function (logLevel, message) {
+ if (logLevel >= this.minimumLogLevel) {
+ switch (logLevel) {
+ case ILogger_1.LogLevel.Critical:
+ case ILogger_1.LogLevel.Error:
+ console.error("[" + new Date().toISOString() + "] " + ILogger_1.LogLevel[logLevel] + ": " + message);
+ break;
+ case ILogger_1.LogLevel.Warning:
+ console.warn("[" + new Date().toISOString() + "] " + ILogger_1.LogLevel[logLevel] + ": " + message);
+ break;
+ case ILogger_1.LogLevel.Information:
+ console.info("[" + new Date().toISOString() + "] " + ILogger_1.LogLevel[logLevel] + ": " + message);
+ break;
+ default:
+ // console.debug only goes to attached debuggers in Node, so we use console.log for Trace and Debug
+ console.log("[" + new Date().toISOString() + "] " + ILogger_1.LogLevel[logLevel] + ": " + message);
+ break;
+ }
+ }
+ };
+ return ConsoleLogger;
+}());
+exports.ConsoleLogger = ConsoleLogger;
+
+
+/***/ }),
+
+/***/ "./Rendering/BrowserRenderer.ts":
+/*!**************************************!*\
+ !*** ./Rendering/BrowserRenderer.ts ***!
+ \**************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var RenderBatch_1 = __webpack_require__(/*! ./RenderBatch/RenderBatch */ "./Rendering/RenderBatch/RenderBatch.ts");
+var EventDelegator_1 = __webpack_require__(/*! ./EventDelegator */ "./Rendering/EventDelegator.ts");
+var LogicalElements_1 = __webpack_require__(/*! ./LogicalElements */ "./Rendering/LogicalElements.ts");
+var ElementReferenceCapture_1 = __webpack_require__(/*! ./ElementReferenceCapture */ "./Rendering/ElementReferenceCapture.ts");
+var selectValuePropname = '_blazorSelectValue';
+var sharedTemplateElemForParsing = document.createElement('template');
+var sharedSvgElemForParsing = document.createElementNS('http://www.w3.org/2000/svg', 'g');
+var preventDefaultEvents = { submit: true };
+var rootComponentsPendingFirstRender = {};
+var BrowserRenderer = /** @class */ (function () {
+ function BrowserRenderer(browserRendererId) {
+ var _this = this;
+ this.childComponentLocations = {};
+ this.browserRendererId = browserRendererId;
+ this.eventDelegator = new EventDelegator_1.EventDelegator(function (event, eventHandlerId, eventArgs) {
+ raiseEvent(event, _this.browserRendererId, eventHandlerId, eventArgs);
+ });
+ }
+ BrowserRenderer.prototype.attachRootComponentToLogicalElement = function (componentId, element) {
+ this.attachComponentToElement(componentId, element);
+ rootComponentsPendingFirstRender[componentId] = element;
+ };
+ BrowserRenderer.prototype.updateComponent = function (batch, componentId, edits, referenceFrames) {
+ var element = this.childComponentLocations[componentId];
+ if (!element) {
+ throw new Error("No element is currently associated with component " + componentId);
+ }
+ // On the first render for each root component, clear any existing content (e.g., prerendered)
+ var rootElementToClear = rootComponentsPendingFirstRender[componentId];
+ if (rootElementToClear) {
+ var rootElementToClearEnd = LogicalElements_1.getLogicalSiblingEnd(rootElementToClear);
+ delete rootComponentsPendingFirstRender[componentId];
+ if (!rootElementToClearEnd) {
+ clearElement(rootElementToClear);
+ }
+ else {
+ clearBetween(rootElementToClear, rootElementToClearEnd);
+ }
+ }
+ this.applyEdits(batch, element, 0, edits, referenceFrames);
+ };
+ BrowserRenderer.prototype.disposeComponent = function (componentId) {
+ delete this.childComponentLocations[componentId];
+ };
+ BrowserRenderer.prototype.disposeEventHandler = function (eventHandlerId) {
+ this.eventDelegator.removeListener(eventHandlerId);
+ };
+ BrowserRenderer.prototype.attachComponentToElement = function (componentId, element) {
+ this.childComponentLocations[componentId] = element;
+ };
+ BrowserRenderer.prototype.applyEdits = function (batch, parent, childIndex, edits, referenceFrames) {
+ var currentDepth = 0;
+ var childIndexAtCurrentDepth = childIndex;
+ var arraySegmentReader = batch.arraySegmentReader;
+ var editReader = batch.editReader;
+ var frameReader = batch.frameReader;
+ var editsValues = arraySegmentReader.values(edits);
+ var editsOffset = arraySegmentReader.offset(edits);
+ var editsLength = arraySegmentReader.count(edits);
+ var maxEditIndexExcl = editsOffset + editsLength;
+ for (var editIndex = editsOffset; editIndex < maxEditIndexExcl; editIndex++) {
+ var edit = batch.diffReader.editsEntry(editsValues, editIndex);
+ var editType = editReader.editType(edit);
+ switch (editType) {
+ case RenderBatch_1.EditType.prependFrame: {
+ var frameIndex = editReader.newTreeIndex(edit);
+ var frame = batch.referenceFramesEntry(referenceFrames, frameIndex);
+ var siblingIndex = editReader.siblingIndex(edit);
+ this.insertFrame(batch, parent, childIndexAtCurrentDepth + siblingIndex, referenceFrames, frame, frameIndex);
+ break;
+ }
+ case RenderBatch_1.EditType.removeFrame: {
+ var siblingIndex = editReader.siblingIndex(edit);
+ LogicalElements_1.removeLogicalChild(parent, childIndexAtCurrentDepth + siblingIndex);
+ break;
+ }
+ case RenderBatch_1.EditType.setAttribute: {
+ var frameIndex = editReader.newTreeIndex(edit);
+ var frame = batch.referenceFramesEntry(referenceFrames, frameIndex);
+ var siblingIndex = editReader.siblingIndex(edit);
+ var element = LogicalElements_1.getLogicalChild(parent, childIndexAtCurrentDepth + siblingIndex);
+ if (element instanceof Element) {
+ this.applyAttribute(batch, element, frame);
+ }
+ else {
+ throw new Error('Cannot set attribute on non-element child');
+ }
+ break;
+ }
+ case RenderBatch_1.EditType.removeAttribute: {
+ // Note that we don't have to dispose the info we track about event handlers here, because the
+ // disposed event handler IDs are delivered separately (in the 'disposedEventHandlerIds' array)
+ var siblingIndex = editReader.siblingIndex(edit);
+ var element = LogicalElements_1.getLogicalChild(parent, childIndexAtCurrentDepth + siblingIndex);
+ if (element instanceof HTMLElement) {
+ var attributeName = editReader.removedAttributeName(edit);
+ // First try to remove any special property we use for this attribute
+ if (!this.tryApplySpecialProperty(batch, element, attributeName, null)) {
+ // If that's not applicable, it's a regular DOM attribute so remove that
+ element.removeAttribute(attributeName);
+ }
+ }
+ else {
+ throw new Error('Cannot remove attribute from non-element child');
+ }
+ break;
+ }
+ case RenderBatch_1.EditType.updateText: {
+ var frameIndex = editReader.newTreeIndex(edit);
+ var frame = batch.referenceFramesEntry(referenceFrames, frameIndex);
+ var siblingIndex = editReader.siblingIndex(edit);
+ var textNode = LogicalElements_1.getLogicalChild(parent, childIndexAtCurrentDepth + siblingIndex);
+ if (textNode instanceof Text) {
+ textNode.textContent = frameReader.textContent(frame);
+ }
+ else {
+ throw new Error('Cannot set text content on non-text child');
+ }
+ break;
+ }
+ case RenderBatch_1.EditType.updateMarkup: {
+ var frameIndex = editReader.newTreeIndex(edit);
+ var frame = batch.referenceFramesEntry(referenceFrames, frameIndex);
+ var siblingIndex = editReader.siblingIndex(edit);
+ LogicalElements_1.removeLogicalChild(parent, childIndexAtCurrentDepth + siblingIndex);
+ this.insertMarkup(batch, parent, childIndexAtCurrentDepth + siblingIndex, frame);
+ break;
+ }
+ case RenderBatch_1.EditType.stepIn: {
+ var siblingIndex = editReader.siblingIndex(edit);
+ parent = LogicalElements_1.getLogicalChild(parent, childIndexAtCurrentDepth + siblingIndex);
+ currentDepth++;
+ childIndexAtCurrentDepth = 0;
+ break;
+ }
+ case RenderBatch_1.EditType.stepOut: {
+ parent = LogicalElements_1.getLogicalParent(parent);
+ currentDepth--;
+ childIndexAtCurrentDepth = currentDepth === 0 ? childIndex : 0; // The childIndex is only ever nonzero at zero depth
+ break;
+ }
+ default: {
+ var unknownType = editType; // Compile-time verification that the switch was exhaustive
+ throw new Error("Unknown edit type: " + unknownType);
+ }
+ }
+ }
+ };
+ BrowserRenderer.prototype.insertFrame = function (batch, parent, childIndex, frames, frame, frameIndex) {
+ var frameReader = batch.frameReader;
+ var frameType = frameReader.frameType(frame);
+ switch (frameType) {
+ case RenderBatch_1.FrameType.element:
+ this.insertElement(batch, parent, childIndex, frames, frame, frameIndex);
+ return 1;
+ case RenderBatch_1.FrameType.text:
+ this.insertText(batch, parent, childIndex, frame);
+ return 1;
+ case RenderBatch_1.FrameType.attribute:
+ throw new Error('Attribute frames should only be present as leading children of element frames.');
+ case RenderBatch_1.FrameType.component:
+ this.insertComponent(batch, parent, childIndex, frame);
+ return 1;
+ case RenderBatch_1.FrameType.region:
+ return this.insertFrameRange(batch, parent, childIndex, frames, frameIndex + 1, frameIndex + frameReader.subtreeLength(frame));
+ case RenderBatch_1.FrameType.elementReferenceCapture:
+ if (parent instanceof Element) {
+ ElementReferenceCapture_1.applyCaptureIdToElement(parent, frameReader.elementReferenceCaptureId(frame));
+ return 0; // A "capture" is a child in the diff, but has no node in the DOM
+ }
+ else {
+ throw new Error('Reference capture frames can only be children of element frames.');
+ }
+ case RenderBatch_1.FrameType.markup:
+ this.insertMarkup(batch, parent, childIndex, frame);
+ return 1;
+ default:
+ var unknownType = frameType; // Compile-time verification that the switch was exhaustive
+ throw new Error("Unknown frame type: " + unknownType);
+ }
+ };
+ BrowserRenderer.prototype.insertElement = function (batch, parent, childIndex, frames, frame, frameIndex) {
+ var frameReader = batch.frameReader;
+ var tagName = frameReader.elementName(frame);
+ var newDomElementRaw = tagName === 'svg' || LogicalElements_1.isSvgElement(parent) ?
+ document.createElementNS('http://www.w3.org/2000/svg', tagName) :
+ document.createElement(tagName);
+ var newElement = LogicalElements_1.toLogicalElement(newDomElementRaw);
+ LogicalElements_1.insertLogicalChild(newDomElementRaw, parent, childIndex);
+ // Apply attributes
+ var descendantsEndIndexExcl = frameIndex + frameReader.subtreeLength(frame);
+ for (var descendantIndex = frameIndex + 1; descendantIndex < descendantsEndIndexExcl; descendantIndex++) {
+ var descendantFrame = batch.referenceFramesEntry(frames, descendantIndex);
+ if (frameReader.frameType(descendantFrame) === RenderBatch_1.FrameType.attribute) {
+ this.applyAttribute(batch, newDomElementRaw, descendantFrame);
+ }
+ else {
+ // As soon as we see a non-attribute child, all the subsequent child frames are
+ // not attributes, so bail out and insert the remnants recursively
+ this.insertFrameRange(batch, newElement, 0, frames, descendantIndex, descendantsEndIndexExcl);
+ break;
+ }
+ }
+ };
+ BrowserRenderer.prototype.insertComponent = function (batch, parent, childIndex, frame) {
+ var containerElement = LogicalElements_1.createAndInsertLogicalContainer(parent, childIndex);
+ // All we have to do is associate the child component ID with its location. We don't actually
+ // do any rendering here, because the diff for the child will appear later in the render batch.
+ var childComponentId = batch.frameReader.componentId(frame);
+ this.attachComponentToElement(childComponentId, containerElement);
+ };
+ BrowserRenderer.prototype.insertText = function (batch, parent, childIndex, textFrame) {
+ var textContent = batch.frameReader.textContent(textFrame);
+ var newTextNode = document.createTextNode(textContent);
+ LogicalElements_1.insertLogicalChild(newTextNode, parent, childIndex);
+ };
+ BrowserRenderer.prototype.insertMarkup = function (batch, parent, childIndex, markupFrame) {
+ var markupContainer = LogicalElements_1.createAndInsertLogicalContainer(parent, childIndex);
+ var markupContent = batch.frameReader.markupContent(markupFrame);
+ var parsedMarkup = parseMarkup(markupContent, LogicalElements_1.isSvgElement(parent));
+ var logicalSiblingIndex = 0;
+ while (parsedMarkup.firstChild) {
+ LogicalElements_1.insertLogicalChild(parsedMarkup.firstChild, markupContainer, logicalSiblingIndex++);
+ }
+ };
+ BrowserRenderer.prototype.applyAttribute = function (batch, toDomElement, attributeFrame) {
+ var frameReader = batch.frameReader;
+ var attributeName = frameReader.attributeName(attributeFrame);
+ var browserRendererId = this.browserRendererId;
+ var eventHandlerId = frameReader.attributeEventHandlerId(attributeFrame);
+ if (eventHandlerId) {
+ var firstTwoChars = attributeName.substring(0, 2);
+ var eventName = attributeName.substring(2);
+ if (firstTwoChars !== 'on' || !eventName) {
+ throw new Error("Attribute has nonzero event handler ID, but attribute name '" + attributeName + "' does not start with 'on'.");
+ }
+ this.eventDelegator.setListener(toDomElement, eventName, eventHandlerId);
+ return;
+ }
+ // First see if we have special handling for this attribute
+ if (!this.tryApplySpecialProperty(batch, toDomElement, attributeName, attributeFrame)) {
+ // If not, treat it as a regular string-valued attribute
+ toDomElement.setAttribute(attributeName, frameReader.attributeValue(attributeFrame));
+ }
+ };
+ BrowserRenderer.prototype.tryApplySpecialProperty = function (batch, element, attributeName, attributeFrame) {
+ switch (attributeName) {
+ case 'value':
+ return this.tryApplyValueProperty(batch, element, attributeFrame);
+ case 'checked':
+ return this.tryApplyCheckedProperty(batch, element, attributeFrame);
+ default:
+ return false;
+ }
+ };
+ BrowserRenderer.prototype.tryApplyValueProperty = function (batch, element, attributeFrame) {
+ // Certain elements have built-in behaviour for their 'value' property
+ var frameReader = batch.frameReader;
+ switch (element.tagName) {
+ case 'INPUT':
+ case 'SELECT':
+ case 'TEXTAREA': {
+ var value = attributeFrame ? frameReader.attributeValue(attributeFrame) : null;
+ element.value = value;
+ if (element.tagName === 'SELECT') {
+ //