import require$$0 from "util";
import stream from "stream";
import require$$4 from "https";
import require$$5 from "url";
import require$$6 from "fs";
import require$$1 from "crypto";
import require$$4$2 from "assert";
import require$$1$1 from "buffer";
import require$$2 from "child_process";
import require$$4$1 from "events";
import require$$8 from "net";
import require$$10 from "tls";
import { c as commonjsGlobal, g as getDefaultExportFromCjs } from "./vendor-tiptap-DRFaxGEb.js";
import require$$3 from "http";
class u {
  constructor() {
    this.notificationCreatedEvent = ".Illuminate\\Notifications\\Events\\BroadcastNotificationCreated";
  }
  /**
   * Listen for a whisper event on the channel instance.
   */
  listenForWhisper(e, t) {
    return this.listen(".client-" + e, t);
  }
  /**
   * Listen for an event on the channel instance.
   */
  notification(e) {
    return this.listen(this.notificationCreatedEvent, e);
  }
  /**
   * Stop listening for notification events on the channel instance.
   */
  stopListeningForNotification(e) {
    return this.stopListening(this.notificationCreatedEvent, e);
  }
  /**
   * Stop listening for a whisper event on the channel instance.
   */
  stopListeningForWhisper(e, t) {
    return this.stopListening(".client-" + e, t);
  }
}
class d {
  /**
   * Create a new class instance.
   */
  constructor(e) {
    this.namespace = e;
  }
  /**
   * Format the given event name.
   */
  format(e) {
    return [".", "\\"].includes(e.charAt(0)) ? e.substring(1) : (this.namespace && (e = this.namespace + "." + e), e.replace(/\./g, "\\"));
  }
  /**
   * Set the event namespace.
   */
  setNamespace(e) {
    this.namespace = e;
  }
}
function g(s) {
  try {
    return Reflect.construct(String, [], s), true;
  } catch {
    return false;
  }
}
class l extends u {
  /**
   * Create a new class instance.
   */
  constructor(e, t, n) {
    super(), this.name = t, this.pusher = e, this.options = n, this.eventFormatter = new d(this.options.namespace), this.subscribe();
  }
  /**
   * Subscribe to a Pusher channel.
   */
  subscribe() {
    this.subscription = this.pusher.subscribe(this.name);
  }
  /**
   * Unsubscribe from a Pusher channel.
   */
  unsubscribe() {
    this.pusher.unsubscribe(this.name);
  }
  /**
   * Listen for an event on the channel instance.
   */
  listen(e, t) {
    return this.on(this.eventFormatter.format(e), t), this;
  }
  /**
   * Listen for all events on the channel instance.
   */
  listenToAll(e) {
    return this.subscription.bind_global((t, n) => {
      if (t.startsWith("pusher:"))
        return;
      let i = String(this.options.namespace ?? "").replace(
        /\./g,
        "\\"
      ), a = t.startsWith(i) ? t.substring(i.length + 1) : "." + t;
      e(a, n);
    }), this;
  }
  /**
   * Stop listening for an event on the channel instance.
   */
  stopListening(e, t) {
    return t ? this.subscription.unbind(
      this.eventFormatter.format(e),
      t
    ) : this.subscription.unbind(this.eventFormatter.format(e)), this;
  }
  /**
   * Stop listening for all events on the channel instance.
   */
  stopListeningToAll(e) {
    return e ? this.subscription.unbind_global(e) : this.subscription.unbind_global(), this;
  }
  /**
   * Register a callback to be called anytime a subscription succeeds.
   */
  subscribed(e) {
    return this.on("pusher:subscription_succeeded", () => {
      e();
    }), this;
  }
  /**
   * Register a callback to be called anytime a subscription error occurs.
   */
  error(e) {
    return this.on("pusher:subscription_error", (t) => {
      e(t);
    }), this;
  }
  /**
   * Bind a channel to an event.
   */
  on(e, t) {
    return this.subscription.bind(e, t), this;
  }
}
class f extends l {
  /**
   * Send a whisper event to other clients in the channel.
   */
  whisper(e, t) {
    return this.pusher.channels.channels[this.name].trigger(
      `client-${e}`,
      t
    ), this;
  }
}
class w extends l {
  /**
   * Send a whisper event to other clients in the channel.
   */
  whisper(e, t) {
    return this.pusher.channels.channels[this.name].trigger(
      `client-${e}`,
      t
    ), this;
  }
}
class _ extends f {
  /**
   * Register a callback to be called anytime the member list changes.
   */
  here(e) {
    return this.on("pusher:subscription_succeeded", (t) => {
      e(Object.keys(t.members).map((n) => t.members[n]));
    }), this;
  }
  /**
   * Listen for someone joining the channel.
   */
  joining(e) {
    return this.on("pusher:member_added", (t) => {
      e(t.info);
    }), this;
  }
  /**
   * Send a whisper event to other clients in the channel.
   */
  whisper(e, t) {
    return this.pusher.channels.channels[this.name].trigger(
      `client-${e}`,
      t
    ), this;
  }
  /**
   * Listen for someone leaving the channel.
   */
  leaving(e) {
    return this.on("pusher:member_removed", (t) => {
      e(t.info);
    }), this;
  }
}
class b extends u {
  /**
   * Create a new class instance.
   */
  constructor(e, t, n) {
    super(), this.events = {}, this.listeners = {}, this.name = t, this.socket = e, this.options = n, this.eventFormatter = new d(this.options.namespace), this.subscribe();
  }
  /**
   * Subscribe to a Socket.io channel.
   */
  subscribe() {
    this.socket.emit("subscribe", {
      channel: this.name,
      auth: this.options.auth || {}
    });
  }
  /**
   * Unsubscribe from channel and ubind event callbacks.
   */
  unsubscribe() {
    this.unbind(), this.socket.emit("unsubscribe", {
      channel: this.name,
      auth: this.options.auth || {}
    });
  }
  /**
   * Listen for an event on the channel instance.
   */
  listen(e, t) {
    return this.on(this.eventFormatter.format(e), t), this;
  }
  /**
   * Stop listening for an event on the channel instance.
   */
  stopListening(e, t) {
    return this.unbindEvent(this.eventFormatter.format(e), t), this;
  }
  /**
   * Register a callback to be called anytime a subscription succeeds.
   */
  subscribed(e) {
    return this.on("connect", (t) => {
      e(t);
    }), this;
  }
  /**
   * Register a callback to be called anytime an error occurs.
   */
  error(e) {
    return this;
  }
  /**
   * Bind the channel's socket to an event and store the callback.
   */
  on(e, t) {
    return this.listeners[e] = this.listeners[e] || [], this.events[e] || (this.events[e] = (n, i) => {
      this.name === n && this.listeners[e] && this.listeners[e].forEach((a) => a(i));
    }, this.socket.on(e, this.events[e])), this.listeners[e].push(t), this;
  }
  /**
   * Unbind the channel's socket from all stored event callbacks.
   */
  unbind() {
    Object.keys(this.events).forEach((e) => {
      this.unbindEvent(e);
    });
  }
  /**
   * Unbind the listeners for the given event.
   */
  unbindEvent(e, t) {
    this.listeners[e] = this.listeners[e] || [], t && (this.listeners[e] = this.listeners[e].filter(
      (n) => n !== t
    )), (!t || this.listeners[e].length === 0) && (this.events[e] && (this.socket.removeListener(e, this.events[e]), delete this.events[e]), delete this.listeners[e]);
  }
}
class v extends b {
  /**
   * Send a whisper event to other clients in the channel.
   */
  whisper(e, t) {
    return this.socket.emit("client event", {
      channel: this.name,
      event: `client-${e}`,
      data: t
    }), this;
  }
}
class C extends v {
  /**
   * Register a callback to be called anytime the member list changes.
   */
  here(e) {
    return this.on("presence:subscribed", (t) => {
      e(t.map((n) => n.user_info));
    }), this;
  }
  /**
   * Listen for someone joining the channel.
   */
  joining(e) {
    return this.on(
      "presence:joining",
      (t) => e(t.user_info)
    ), this;
  }
  /**
   * Send a whisper event to other clients in the channel.
   */
  whisper(e, t) {
    return this.socket.emit("client event", {
      channel: this.name,
      event: `client-${e}`,
      data: t
    }), this;
  }
  /**
   * Listen for someone leaving the channel.
   */
  leaving(e) {
    return this.on(
      "presence:leaving",
      (t) => e(t.user_info)
    ), this;
  }
}
class c extends u {
  /**
   * Subscribe to a channel.
   */
  subscribe() {
  }
  /**
   * Unsubscribe from a channel.
   */
  unsubscribe() {
  }
  /**
   * Listen for an event on the channel instance.
   */
  listen(e, t) {
    return this;
  }
  /**
   * Listen for all events on the channel instance.
   */
  listenToAll(e) {
    return this;
  }
  /**
   * Stop listening for an event on the channel instance.
   */
  stopListening(e, t) {
    return this;
  }
  /**
   * Register a callback to be called anytime a subscription succeeds.
   */
  subscribed(e) {
    return this;
  }
  /**
   * Register a callback to be called anytime an error occurs.
   */
  error(e) {
    return this;
  }
  /**
   * Bind a channel to an event.
   */
  on(e, t) {
    return this;
  }
}
class k extends c {
  /**
   * Send a whisper event to other clients in the channel.
   */
  whisper(e, t) {
    return this;
  }
}
class y extends c {
  /**
   * Send a whisper event to other clients in the channel.
   */
  whisper(e, t) {
    return this;
  }
}
class m extends k {
  /**
   * Register a callback to be called anytime the member list changes.
   */
  here(e) {
    return this;
  }
  /**
   * Listen for someone joining the channel.
   */
  joining(e) {
    return this;
  }
  /**
   * Send a whisper event to other clients in the channel.
   */
  whisper(e, t) {
    return this;
  }
  /**
   * Listen for someone leaving the channel.
   */
  leaving(e) {
    return this;
  }
}
const h = class h2 {
  /**
   * Create a new class instance.
   */
  constructor(e) {
    this.setOptions(e), this.connect();
  }
  /**
   * Merge the custom options with the defaults.
   */
  setOptions(e) {
    this.options = {
      ...h2._defaultOptions,
      ...e,
      broadcaster: e.broadcaster
    };
    let t = this.csrfToken();
    t && (this.options.auth.headers["X-CSRF-TOKEN"] = t, this.options.userAuthentication.headers["X-CSRF-TOKEN"] = t), t = this.options.bearerToken, t && (this.options.auth.headers.Authorization = "Bearer " + t, this.options.userAuthentication.headers.Authorization = "Bearer " + t);
  }
  /**
   * Extract the CSRF token from the page.
   */
  csrfToken() {
    var e, t;
    return typeof window < "u" && ((e = window.Laravel) != null && e.csrfToken) ? window.Laravel.csrfToken : this.options.csrfToken ? this.options.csrfToken : typeof document < "u" && typeof document.querySelector == "function" ? ((t = document.querySelector('meta[name="csrf-token"]')) == null ? void 0 : t.getAttribute("content")) ?? null : null;
  }
};
h._defaultOptions = {
  auth: {
    headers: {}
  },
  authEndpoint: "/broadcasting/auth",
  userAuthentication: {
    endpoint: "/broadcasting/user-auth",
    headers: {}
  },
  csrfToken: null,
  bearerToken: null,
  host: null,
  key: null,
  namespace: "App.Events"
};
let r = h;
class o extends r {
  constructor() {
    super(...arguments), this.channels = {};
  }
  /**
   * Create a fresh Pusher connection.
   */
  connect() {
    if (typeof this.options.client < "u")
      this.pusher = this.options.client;
    else if (this.options.Pusher)
      this.pusher = new this.options.Pusher(
        this.options.key,
        this.options
      );
    else if (typeof window < "u" && typeof window.Pusher < "u")
      this.pusher = new window.Pusher(this.options.key, this.options);
    else
      throw new Error(
        "Pusher client not found. Should be globally available or passed via options.client"
      );
  }
  /**
   * Sign in the user via Pusher user authentication (https://pusher.com/docs/channels/using_channels/user-authentication/).
   */
  signin() {
    this.pusher.signin();
  }
  /**
   * Listen for an event on a channel instance.
   */
  listen(e, t, n) {
    return this.channel(e).listen(t, n);
  }
  /**
   * Get a channel instance by name.
   */
  channel(e) {
    return this.channels[e] || (this.channels[e] = new l(
      this.pusher,
      e,
      this.options
    )), this.channels[e];
  }
  /**
   * Get a private channel instance by name.
   */
  privateChannel(e) {
    return this.channels["private-" + e] || (this.channels["private-" + e] = new f(
      this.pusher,
      "private-" + e,
      this.options
    )), this.channels["private-" + e];
  }
  /**
   * Get a private encrypted channel instance by name.
   */
  encryptedPrivateChannel(e) {
    return this.channels["private-encrypted-" + e] || (this.channels["private-encrypted-" + e] = new w(
      this.pusher,
      "private-encrypted-" + e,
      this.options
    )), this.channels["private-encrypted-" + e];
  }
  /**
   * Get a presence channel instance by name.
   */
  presenceChannel(e) {
    return this.channels["presence-" + e] || (this.channels["presence-" + e] = new _(
      this.pusher,
      "presence-" + e,
      this.options
    )), this.channels["presence-" + e];
  }
  /**
   * Leave the given channel, as well as its private and presence variants.
   */
  leave(e) {
    [
      e,
      "private-" + e,
      "private-encrypted-" + e,
      "presence-" + e
    ].forEach((n) => {
      this.leaveChannel(n);
    });
  }
  /**
   * Leave the given channel.
   */
  leaveChannel(e) {
    this.channels[e] && (this.channels[e].unsubscribe(), delete this.channels[e]);
  }
  /**
   * Get the socket ID for the connection.
   */
  socketId() {
    return this.pusher.connection.socket_id;
  }
  /**
   * Get the current connection status.
   */
  connectionStatus() {
    const e = this.pusher.connection.state;
    switch (e) {
      case "connected":
      case "connecting":
        return e;
      case "failed":
      case "unavailable":
        return "failed";
      default:
        return "disconnected";
    }
  }
  /**
   * Subscribe to connection status changes.
   */
  onConnectionChange(e) {
    const t = () => {
      e(this.connectionStatus());
    }, n = ["state_change", "connected", "disconnected"];
    return n.forEach((i) => {
      this.pusher.connection.bind(i, t);
    }), () => {
      n.forEach((i) => {
        this.pusher.connection.unbind(i, t);
      });
    };
  }
  /**
   * Disconnect Pusher connection.
   */
  disconnect() {
    this.pusher.disconnect();
  }
}
class S extends r {
  constructor() {
    super(...arguments), this.channels = {};
  }
  /**
   * Create a fresh Socket.io connection.
   */
  connect() {
    let e = this.getSocketIO();
    this.socket = e(
      this.options.host ?? void 0,
      this.options
    ), this.socket.io.on("reconnect", () => {
      Object.values(this.channels).forEach((t) => {
        t.subscribe();
      });
    });
  }
  /**
   * Get socket.io module from global scope or options.
   */
  getSocketIO() {
    if (typeof this.options.client < "u")
      return this.options.client;
    if (typeof window < "u" && typeof window.io < "u")
      return window.io;
    throw new Error(
      "Socket.io client not found. Should be globally available or passed via options.client"
    );
  }
  /**
   * Listen for an event on a channel instance.
   */
  listen(e, t, n) {
    return this.channel(e).listen(t, n);
  }
  /**
   * Get a channel instance by name.
   */
  channel(e) {
    return this.channels[e] || (this.channels[e] = new b(
      this.socket,
      e,
      this.options
    )), this.channels[e];
  }
  /**
   * Get a private channel instance by name.
   */
  privateChannel(e) {
    return this.channels["private-" + e] || (this.channels["private-" + e] = new v(
      this.socket,
      "private-" + e,
      this.options
    )), this.channels["private-" + e];
  }
  /**
   * Get a presence channel instance by name.
   */
  presenceChannel(e) {
    return this.channels["presence-" + e] || (this.channels["presence-" + e] = new C(
      this.socket,
      "presence-" + e,
      this.options
    )), this.channels["presence-" + e];
  }
  /**
   * Leave the given channel, as well as its private and presence variants.
   */
  leave(e) {
    [e, "private-" + e, "presence-" + e].forEach((n) => {
      this.leaveChannel(n);
    });
  }
  /**
   * Leave the given channel.
   */
  leaveChannel(e) {
    this.channels[e] && (this.channels[e].unsubscribe(), delete this.channels[e]);
  }
  /**
   * Get the socket ID for the connection.
   */
  socketId() {
    return this.socket.id;
  }
  /**
   * Get the current connection status.
   */
  connectionStatus() {
    return this.socket.connected ? "connected" : this.socket.io._reconnecting ? "reconnecting" : this.socket.id !== void 0 ? "disconnected" : "connecting";
  }
  /**
   * Subscribe to connection status changes.
   */
  onConnectionChange(e) {
    const t = () => {
      e(this.connectionStatus());
    }, n = [
      "connect",
      "disconnect",
      "connect_error",
      "reconnect_attempt",
      "reconnect",
      "reconnect_error",
      "reconnect_failed"
    ];
    return n.forEach((i) => {
      this.socket.on(i, t);
    }), () => {
      n.forEach((i) => {
        this.socket.off(i, t);
      });
    };
  }
  /**
   * Disconnect Socketio connection.
   */
  disconnect() {
    this.socket.disconnect();
  }
}
class p extends r {
  constructor() {
    super(...arguments), this.channels = {};
  }
  /**
   * Create a fresh connection.
   */
  connect() {
  }
  /**
   * Listen for an event on a channel instance.
   */
  listen(e, t, n) {
    return new c();
  }
  /**
   * Get a channel instance by name.
   */
  channel(e) {
    return new c();
  }
  /**
   * Get a private channel instance by name.
   */
  privateChannel(e) {
    return new k();
  }
  /**
   * Get a private encrypted channel instance by name.
   */
  encryptedPrivateChannel(e) {
    return new y();
  }
  /**
   * Get a presence channel instance by name.
   */
  presenceChannel(e) {
    return new m();
  }
  /**
   * Leave the given channel, as well as its private and presence variants.
   */
  leave(e) {
  }
  /**
   * Leave the given channel.
   */
  leaveChannel(e) {
  }
  /**
   * Get the socket ID for the connection.
   */
  socketId() {
    return "fake-socket-id";
  }
  /**
   * Get the current connection status.
   */
  connectionStatus() {
    return "connected";
  }
  /**
   * Subscribe to connection status changes.
   */
  onConnectionChange(e) {
    return () => {
    };
  }
  /**
   * Disconnect the connection.
   */
  disconnect() {
  }
}
class E {
  /**
   * Create a new class instance.
   */
  constructor(e) {
    this.options = e, this.connect(), this.options.withoutInterceptors || this.registerInterceptors();
  }
  /**
   * Get a channel instance by name.
   */
  channel(e) {
    return this.connector.channel(e);
  }
  /**
   * Create a new connection.
   */
  connect() {
    if (this.options.broadcaster === "reverb")
      this.connector = new o({
        ...this.options,
        cluster: ""
      });
    else if (this.options.broadcaster === "pusher")
      this.connector = new o(this.options);
    else if (this.options.broadcaster === "ably")
      this.connector = new o({
        ...this.options,
        cluster: "",
        broadcaster: "pusher"
      });
    else if (this.options.broadcaster === "socket.io")
      this.connector = new S(this.options);
    else if (this.options.broadcaster === "null")
      this.connector = new p(this.options);
    else if (typeof this.options.broadcaster == "function" && g(this.options.broadcaster))
      this.connector = new this.options.broadcaster(this.options);
    else
      throw new Error(
        `Broadcaster ${typeof this.options.broadcaster} ${String(this.options.broadcaster)} is not supported.`
      );
  }
  /**
   * Disconnect from the Echo server.
   */
  disconnect() {
    this.connector.disconnect();
  }
  /**
   * Get a presence channel instance by name.
   */
  join(e) {
    return this.connector.presenceChannel(e);
  }
  /**
   * Leave the given channel, as well as its private and presence variants.
   */
  leave(e) {
    this.connector.leave(e);
  }
  /**
   * Leave the given channel.
   */
  leaveChannel(e) {
    this.connector.leaveChannel(e);
  }
  /**
   * Leave all channels.
   */
  leaveAllChannels() {
    for (const e in this.connector.channels)
      this.leaveChannel(e);
  }
  /**
   * Listen for an event on a channel instance.
   */
  listen(e, t, n) {
    return this.connector.listen(e, t, n);
  }
  /**
   * Get a private channel instance by name.
   */
  private(e) {
    return this.connector.privateChannel(e);
  }
  /**
   * Get a private encrypted channel instance by name.
   */
  encryptedPrivate(e) {
    if (this.connectorSupportsEncryptedPrivateChannels(this.connector))
      return this.connector.encryptedPrivateChannel(e);
    throw new Error(
      `Broadcaster ${typeof this.options.broadcaster} ${String(
        this.options.broadcaster
      )} does not support encrypted private channels.`
    );
  }
  connectorSupportsEncryptedPrivateChannels(e) {
    return e instanceof o || e instanceof p;
  }
  /**
   * Get the Socket ID for the connection.
   */
  socketId() {
    return this.connector.socketId();
  }
  /**
   * Get the current connection status.
   */
  connectionStatus() {
    return this.connector.connectionStatus();
  }
  /**
   * Register 3rd party request interceptors. These are used to automatically
   * send a connections socket id to a Laravel app with a X-Socket-Id header.
   */
  registerInterceptors() {
    typeof Vue < "u" && (Vue != null && Vue.http) && this.registerVueRequestInterceptor(), typeof axios == "function" && this.registerAxiosRequestInterceptor(), typeof jQuery == "function" && this.registerjQueryAjaxSetup(), typeof Turbo == "object" && this.registerTurboRequestInterceptor();
  }
  /**
   * Register a Vue HTTP interceptor to add the X-Socket-ID header.
   */
  registerVueRequestInterceptor() {
    Vue.http.interceptors.push(
      (e, t) => {
        this.socketId() && e.headers.set("X-Socket-ID", this.socketId()), t();
      }
    );
  }
  /**
   * Register an Axios HTTP interceptor to add the X-Socket-ID header.
   */
  registerAxiosRequestInterceptor() {
    axios.interceptors.request.use(
      (e) => (this.socketId() && (e.headers["X-Socket-Id"] = this.socketId()), e)
    );
  }
  /**
   * Register jQuery AjaxPrefilter to add the X-Socket-ID header.
   */
  registerjQueryAjaxSetup() {
    typeof jQuery.ajax < "u" && jQuery.ajaxPrefilter(
      (e, t, n) => {
        this.socketId() && n.setRequestHeader("X-Socket-Id", this.socketId());
      }
    );
  }
  /**
   * Register the Turbo Request interceptor to add the X-Socket-ID header.
   */
  registerTurboRequestInterceptor() {
    document.addEventListener(
      "turbo:before-fetch-request",
      (e) => {
        e.detail.fetchOptions.headers["X-Socket-Id"] = this.socketId();
      }
    );
  }
}
var pusher = { exports: {} };
var hasRequiredPusher;
function requirePusher() {
  if (hasRequiredPusher) return pusher.exports;
  hasRequiredPusher = 1;
  (function(module) {
    (() => {
      var __webpack_modules__ = {
        /***/
        594(__unused_webpack_module, exports$1) {
          var __extends = this && this.__extends || /* @__PURE__ */ (function() {
            var extendStatics = function(d2, b2) {
              extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d3, b3) {
                d3.__proto__ = b3;
              } || function(d3, b3) {
                for (var p2 in b3) if (b3.hasOwnProperty(p2)) d3[p2] = b3[p2];
              };
              return extendStatics(d2, b2);
            };
            return function(d2, b2) {
              extendStatics(d2, b2);
              function __() {
                this.constructor = d2;
              }
              d2.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __());
            };
          })();
          Object.defineProperty(exports$1, "__esModule", { value: true });
          var INVALID_BYTE = 256;
          var Coder = (
            /** @class */
            (function() {
              function Coder2(_paddingCharacter) {
                if (_paddingCharacter === void 0) {
                  _paddingCharacter = "=";
                }
                this._paddingCharacter = _paddingCharacter;
              }
              Coder2.prototype.encodedLength = function(length) {
                if (!this._paddingCharacter) {
                  return (length * 8 + 5) / 6 | 0;
                }
                return (length + 2) / 3 * 4 | 0;
              };
              Coder2.prototype.encode = function(data) {
                var out = "";
                var i = 0;
                for (; i < data.length - 2; i += 3) {
                  var c2 = data[i] << 16 | data[i + 1] << 8 | data[i + 2];
                  out += this._encodeByte(c2 >>> 3 * 6 & 63);
                  out += this._encodeByte(c2 >>> 2 * 6 & 63);
                  out += this._encodeByte(c2 >>> 1 * 6 & 63);
                  out += this._encodeByte(c2 >>> 0 * 6 & 63);
                }
                var left = data.length - i;
                if (left > 0) {
                  var c2 = data[i] << 16 | (left === 2 ? data[i + 1] << 8 : 0);
                  out += this._encodeByte(c2 >>> 3 * 6 & 63);
                  out += this._encodeByte(c2 >>> 2 * 6 & 63);
                  if (left === 2) {
                    out += this._encodeByte(c2 >>> 1 * 6 & 63);
                  } else {
                    out += this._paddingCharacter || "";
                  }
                  out += this._paddingCharacter || "";
                }
                return out;
              };
              Coder2.prototype.maxDecodedLength = function(length) {
                if (!this._paddingCharacter) {
                  return (length * 6 + 7) / 8 | 0;
                }
                return length / 4 * 3 | 0;
              };
              Coder2.prototype.decodedLength = function(s) {
                return this.maxDecodedLength(s.length - this._getPaddingLength(s));
              };
              Coder2.prototype.decode = function(s) {
                if (s.length === 0) {
                  return new Uint8Array(0);
                }
                var paddingLength = this._getPaddingLength(s);
                var length = s.length - paddingLength;
                var out = new Uint8Array(this.maxDecodedLength(length));
                var op = 0;
                var i = 0;
                var haveBad = 0;
                var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
                for (; i < length - 4; i += 4) {
                  v0 = this._decodeChar(s.charCodeAt(i + 0));
                  v1 = this._decodeChar(s.charCodeAt(i + 1));
                  v2 = this._decodeChar(s.charCodeAt(i + 2));
                  v3 = this._decodeChar(s.charCodeAt(i + 3));
                  out[op++] = v0 << 2 | v1 >>> 4;
                  out[op++] = v1 << 4 | v2 >>> 2;
                  out[op++] = v2 << 6 | v3;
                  haveBad |= v0 & INVALID_BYTE;
                  haveBad |= v1 & INVALID_BYTE;
                  haveBad |= v2 & INVALID_BYTE;
                  haveBad |= v3 & INVALID_BYTE;
                }
                if (i < length - 1) {
                  v0 = this._decodeChar(s.charCodeAt(i));
                  v1 = this._decodeChar(s.charCodeAt(i + 1));
                  out[op++] = v0 << 2 | v1 >>> 4;
                  haveBad |= v0 & INVALID_BYTE;
                  haveBad |= v1 & INVALID_BYTE;
                }
                if (i < length - 2) {
                  v2 = this._decodeChar(s.charCodeAt(i + 2));
                  out[op++] = v1 << 4 | v2 >>> 2;
                  haveBad |= v2 & INVALID_BYTE;
                }
                if (i < length - 3) {
                  v3 = this._decodeChar(s.charCodeAt(i + 3));
                  out[op++] = v2 << 6 | v3;
                  haveBad |= v3 & INVALID_BYTE;
                }
                if (haveBad !== 0) {
                  throw new Error("Base64Coder: incorrect characters for decoding");
                }
                return out;
              };
              Coder2.prototype._encodeByte = function(b2) {
                var result = b2;
                result += 65;
                result += 25 - b2 >>> 8 & 0 - 65 - 26 + 97;
                result += 51 - b2 >>> 8 & 26 - 97 - 52 + 48;
                result += 61 - b2 >>> 8 & 52 - 48 - 62 + 43;
                result += 62 - b2 >>> 8 & 62 - 43 - 63 + 47;
                return String.fromCharCode(result);
              };
              Coder2.prototype._decodeChar = function(c2) {
                var result = INVALID_BYTE;
                result += (42 - c2 & c2 - 44) >>> 8 & -INVALID_BYTE + c2 - 43 + 62;
                result += (46 - c2 & c2 - 48) >>> 8 & -INVALID_BYTE + c2 - 47 + 63;
                result += (47 - c2 & c2 - 58) >>> 8 & -INVALID_BYTE + c2 - 48 + 52;
                result += (64 - c2 & c2 - 91) >>> 8 & -INVALID_BYTE + c2 - 65 + 0;
                result += (96 - c2 & c2 - 123) >>> 8 & -INVALID_BYTE + c2 - 97 + 26;
                return result;
              };
              Coder2.prototype._getPaddingLength = function(s) {
                var paddingLength = 0;
                if (this._paddingCharacter) {
                  for (var i = s.length - 1; i >= 0; i--) {
                    if (s[i] !== this._paddingCharacter) {
                      break;
                    }
                    paddingLength++;
                  }
                  if (s.length < 4 || paddingLength > 2) {
                    throw new Error("Base64Coder: incorrect padding");
                  }
                }
                return paddingLength;
              };
              return Coder2;
            })()
          );
          exports$1.Coder = Coder;
          var stdCoder = new Coder();
          function encode(data) {
            return stdCoder.encode(data);
          }
          exports$1.encode = encode;
          function decode(s) {
            return stdCoder.decode(s);
          }
          exports$1.decode = decode;
          var URLSafeCoder = (
            /** @class */
            (function(_super) {
              __extends(URLSafeCoder2, _super);
              function URLSafeCoder2() {
                return _super !== null && _super.apply(this, arguments) || this;
              }
              URLSafeCoder2.prototype._encodeByte = function(b2) {
                var result = b2;
                result += 65;
                result += 25 - b2 >>> 8 & 0 - 65 - 26 + 97;
                result += 51 - b2 >>> 8 & 26 - 97 - 52 + 48;
                result += 61 - b2 >>> 8 & 52 - 48 - 62 + 45;
                result += 62 - b2 >>> 8 & 62 - 45 - 63 + 95;
                return String.fromCharCode(result);
              };
              URLSafeCoder2.prototype._decodeChar = function(c2) {
                var result = INVALID_BYTE;
                result += (44 - c2 & c2 - 46) >>> 8 & -INVALID_BYTE + c2 - 45 + 62;
                result += (94 - c2 & c2 - 96) >>> 8 & -INVALID_BYTE + c2 - 95 + 63;
                result += (47 - c2 & c2 - 58) >>> 8 & -INVALID_BYTE + c2 - 48 + 52;
                result += (64 - c2 & c2 - 91) >>> 8 & -INVALID_BYTE + c2 - 65 + 0;
                result += (96 - c2 & c2 - 123) >>> 8 & -INVALID_BYTE + c2 - 97 + 26;
                return result;
              };
              return URLSafeCoder2;
            })(Coder)
          );
          exports$1.URLSafeCoder = URLSafeCoder;
          var urlSafeCoder = new URLSafeCoder();
          function encodeURLSafe(data) {
            return urlSafeCoder.encode(data);
          }
          exports$1.encodeURLSafe = encodeURLSafe;
          function decodeURLSafe(s) {
            return urlSafeCoder.decode(s);
          }
          exports$1.decodeURLSafe = decodeURLSafe;
          exports$1.encodedLength = function(length) {
            return stdCoder.encodedLength(length);
          };
          exports$1.maxDecodedLength = function(length) {
            return stdCoder.maxDecodedLength(length);
          };
          exports$1.decodedLength = function(s) {
            return stdCoder.decodedLength(s);
          };
        },
        /***/
        978(__unused_webpack_module, exports$1) {
          var INVALID_UTF8 = "utf8: invalid source encoding";
          function decode(arr) {
            var chars = [];
            for (var i = 0; i < arr.length; i++) {
              var b2 = arr[i];
              if (b2 & 128) {
                var min = void 0;
                if (b2 < 224) {
                  if (i >= arr.length) {
                    throw new Error(INVALID_UTF8);
                  }
                  var n1 = arr[++i];
                  if ((n1 & 192) !== 128) {
                    throw new Error(INVALID_UTF8);
                  }
                  b2 = (b2 & 31) << 6 | n1 & 63;
                  min = 128;
                } else if (b2 < 240) {
                  if (i >= arr.length - 1) {
                    throw new Error(INVALID_UTF8);
                  }
                  var n1 = arr[++i];
                  var n2 = arr[++i];
                  if ((n1 & 192) !== 128 || (n2 & 192) !== 128) {
                    throw new Error(INVALID_UTF8);
                  }
                  b2 = (b2 & 15) << 12 | (n1 & 63) << 6 | n2 & 63;
                  min = 2048;
                } else if (b2 < 248) {
                  if (i >= arr.length - 2) {
                    throw new Error(INVALID_UTF8);
                  }
                  var n1 = arr[++i];
                  var n2 = arr[++i];
                  var n3 = arr[++i];
                  if ((n1 & 192) !== 128 || (n2 & 192) !== 128 || (n3 & 192) !== 128) {
                    throw new Error(INVALID_UTF8);
                  }
                  b2 = (b2 & 15) << 18 | (n1 & 63) << 12 | (n2 & 63) << 6 | n3 & 63;
                  min = 65536;
                } else {
                  throw new Error(INVALID_UTF8);
                }
                if (b2 < min || b2 >= 55296 && b2 <= 57343) {
                  throw new Error(INVALID_UTF8);
                }
                if (b2 >= 65536) {
                  if (b2 > 1114111) {
                    throw new Error(INVALID_UTF8);
                  }
                  b2 -= 65536;
                  chars.push(String.fromCharCode(55296 | b2 >> 10));
                  b2 = 56320 | b2 & 1023;
                }
              }
              chars.push(String.fromCharCode(b2));
            }
            return chars.join("");
          }
          exports$1.D4 = decode;
        },
        /***/
        945(module2, __unused_webpack_exports, __webpack_require__2) {
          var Stream = __webpack_require__2(203).Stream, util = __webpack_require__2(23), driver = __webpack_require__2(41), Headers = __webpack_require__2(160), API = __webpack_require__2(720), EventTarget = __webpack_require__2(667), Event = __webpack_require__2(859);
          var EventSource = function(request, response, options) {
            this.writable = true;
            options = options || {};
            this._stream = response.socket;
            this._ping = options.ping || this.DEFAULT_PING;
            this._retry = options.retry || this.DEFAULT_RETRY;
            var scheme = driver.isSecureRequest(request) ? "https:" : "http:";
            this.url = scheme + "//" + request.headers.host + request.url;
            this.lastEventId = request.headers["last-event-id"] || "";
            this.readyState = API.CONNECTING;
            var headers = new Headers(), self2 = this;
            if (options.headers) {
              for (var key2 in options.headers) headers.set(key2, options.headers[key2]);
            }
            if (!this._stream || !this._stream.writable) return;
            process.nextTick(function() {
              self2._open();
            });
            this._stream.setTimeout(0);
            this._stream.setNoDelay(true);
            var handshake = "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-cache, no-store\r\nConnection: close\r\n" + headers.toString() + "\r\nretry: " + Math.floor(this._retry * 1e3) + "\r\n\r\n";
            this._write(handshake);
            this._stream.on("drain", function() {
              self2.emit("drain");
            });
            if (this._ping)
              this._pingTimer = setInterval(function() {
                self2.ping();
              }, this._ping * 1e3);
            ["error", "end"].forEach(function(event) {
              self2._stream.on(event, function() {
                self2.close();
              });
            });
          };
          util.inherits(EventSource, Stream);
          EventSource.isEventSource = function(request) {
            if (request.method !== "GET") return false;
            var accept = (request.headers.accept || "").split(/\s*,\s*/);
            return accept.indexOf("text/event-stream") >= 0;
          };
          var instance = {
            DEFAULT_PING: 10,
            DEFAULT_RETRY: 5,
            _write: function(chunk) {
              if (!this.writable) return false;
              try {
                return this._stream.write(chunk, "utf8");
              } catch (e) {
                return false;
              }
            },
            _open: function() {
              if (this.readyState !== API.CONNECTING) return;
              this.readyState = API.OPEN;
              var event = new Event("open");
              event.initEvent("open", false, false);
              this.dispatchEvent(event);
            },
            write: function(message) {
              return this.send(message);
            },
            end: function(message) {
              if (message !== void 0) this.write(message);
              this.close();
            },
            send: function(message, options) {
              if (this.readyState > API.OPEN) return false;
              message = String(message).replace(/(\r\n|\r|\n)/g, "$1data: ");
              options = options || {};
              var frame = "";
              if (options.event) frame += "event: " + options.event + "\r\n";
              if (options.id) frame += "id: " + options.id + "\r\n";
              frame += "data: " + message + "\r\n\r\n";
              return this._write(frame);
            },
            ping: function() {
              return this._write(":\r\n\r\n");
            },
            close: function() {
              if (this.readyState > API.OPEN) return false;
              this.readyState = API.CLOSED;
              this.writable = false;
              if (this._pingTimer) clearInterval(this._pingTimer);
              if (this._stream) this._stream.end();
              var event = new Event("close");
              event.initEvent("close", false, false);
              this.dispatchEvent(event);
              return true;
            }
          };
          for (var method in instance) EventSource.prototype[method] = instance[method];
          for (var key in EventTarget) EventSource.prototype[key] = EventTarget[key];
          module2.exports = EventSource;
        },
        /***/
        555(module2, __unused_webpack_exports, __webpack_require__2) {
          var util = __webpack_require__2(23), driver = __webpack_require__2(41), API = __webpack_require__2(720);
          var WebSocket = function(request, socket, body, protocols, options) {
            options = options || {};
            this._stream = socket;
            this._driver = driver.http(request, { maxLength: options.maxLength, protocols });
            var self2 = this;
            if (!this._stream || !this._stream.writable) return;
            if (!this._stream.readable) return this._stream.end();
            var catchup = function() {
              self2._stream.removeListener("data", catchup);
            };
            this._stream.on("data", catchup);
            API.call(this, options);
            process.nextTick(function() {
              self2._driver.start();
              self2._driver.io.write(body);
            });
          };
          util.inherits(WebSocket, API);
          WebSocket.isWebSocket = function(request) {
            return driver.isWebSocket(request);
          };
          WebSocket.validateOptions = function(options, validKeys) {
            driver.validateOptions(options, validKeys);
          };
          WebSocket.WebSocket = WebSocket;
          WebSocket.Client = __webpack_require__2(333);
          WebSocket.EventSource = __webpack_require__2(945);
          module2.exports = WebSocket;
        },
        /***/
        720(module2, __unused_webpack_exports, __webpack_require__2) {
          var Stream = __webpack_require__2(203).Stream, util = __webpack_require__2(23), driver = __webpack_require__2(41), EventTarget = __webpack_require__2(667), Event = __webpack_require__2(859);
          var API = function(options) {
            options = options || {};
            driver.validateOptions(options, ["headers", "extensions", "maxLength", "ping", "proxy", "tls", "ca"]);
            this.readable = this.writable = true;
            var headers = options.headers;
            if (headers) {
              for (var name in headers) this._driver.setHeader(name, headers[name]);
            }
            var extensions = options.extensions;
            if (extensions) {
              [].concat(extensions).forEach(this._driver.addExtension, this._driver);
            }
            this._ping = options.ping;
            this._pingId = 0;
            this.readyState = API.CONNECTING;
            this.bufferedAmount = 0;
            this.protocol = "";
            this.url = this._driver.url;
            this.version = this._driver.version;
            var self2 = this;
            this._driver.on("open", function(e) {
              self2._open();
            });
            this._driver.on("message", function(e) {
              self2._receiveMessage(e.data);
            });
            this._driver.on("close", function(e) {
              self2._beginClose(e.reason, e.code);
            });
            this._driver.on("error", function(error) {
              self2._emitError(error.message);
            });
            this.on("error", function() {
            });
            this._driver.messages.on("drain", function() {
              self2.emit("drain");
            });
            if (this._ping)
              this._pingTimer = setInterval(function() {
                self2._pingId += 1;
                self2.ping(self2._pingId.toString());
              }, this._ping * 1e3);
            this._configureStream();
            if (!this._proxy) {
              this._stream.pipe(this._driver.io);
              this._driver.io.pipe(this._stream);
            }
          };
          util.inherits(API, Stream);
          API.CONNECTING = 0;
          API.OPEN = 1;
          API.CLOSING = 2;
          API.CLOSED = 3;
          API.CLOSE_TIMEOUT = 3e4;
          var instance = {
            write: function(data) {
              return this.send(data);
            },
            end: function(data) {
              if (data !== void 0) this.send(data);
              this.close();
            },
            pause: function() {
              return this._driver.messages.pause();
            },
            resume: function() {
              return this._driver.messages.resume();
            },
            send: function(data) {
              if (this.readyState > API.OPEN) return false;
              if (!(data instanceof Buffer)) data = String(data);
              return this._driver.messages.write(data);
            },
            ping: function(message, callback) {
              if (this.readyState > API.OPEN) return false;
              return this._driver.ping(message, callback);
            },
            close: function(code, reason) {
              if (code === void 0) code = 1e3;
              if (reason === void 0) reason = "";
              if (code !== 1e3 && (code < 3e3 || code > 4999))
                throw new Error("Failed to execute 'close' on WebSocket: The code must be either 1000, or between 3000 and 4999. " + code + " is neither.");
              if (this.readyState !== API.CLOSED) this.readyState = API.CLOSING;
              var self2 = this;
              this._closeTimer = setTimeout(function() {
                self2._beginClose("", 1006);
              }, API.CLOSE_TIMEOUT);
              this._driver.close(reason, code);
            },
            _configureStream: function() {
              var self2 = this;
              this._stream.setTimeout(0);
              this._stream.setNoDelay(true);
              ["close", "end"].forEach(function(event) {
                this._stream.on(event, function() {
                  self2._finalizeClose();
                });
              }, this);
              this._stream.on("error", function(error) {
                self2._emitError("Network error: " + self2.url + ": " + error.message);
                self2._finalizeClose();
              });
            },
            _open: function() {
              if (this.readyState !== API.CONNECTING) return;
              this.readyState = API.OPEN;
              this.protocol = this._driver.protocol || "";
              var event = new Event("open");
              event.initEvent("open", false, false);
              this.dispatchEvent(event);
            },
            _receiveMessage: function(data) {
              if (this.readyState > API.OPEN) return false;
              if (this.readable) this.emit("data", data);
              var event = new Event("message", { data });
              event.initEvent("message", false, false);
              this.dispatchEvent(event);
            },
            _emitError: function(message) {
              if (this.readyState >= API.CLOSING) return;
              var event = new Event("error", { message });
              event.initEvent("error", false, false);
              this.dispatchEvent(event);
            },
            _beginClose: function(reason, code) {
              if (this.readyState === API.CLOSED) return;
              this.readyState = API.CLOSING;
              this._closeParams = [reason, code];
              if (this._stream) {
                this._stream.destroy();
                if (!this._stream.readable) this._finalizeClose();
              }
            },
            _finalizeClose: function() {
              if (this.readyState === API.CLOSED) return;
              this.readyState = API.CLOSED;
              if (this._closeTimer) clearTimeout(this._closeTimer);
              if (this._pingTimer) clearInterval(this._pingTimer);
              if (this._stream) this._stream.end();
              if (this.readable) this.emit("end");
              this.readable = this.writable = false;
              var reason = this._closeParams ? this._closeParams[0] : "", code = this._closeParams ? this._closeParams[1] : 1006;
              var event = new Event("close", { code, reason });
              event.initEvent("close", false, false);
              this.dispatchEvent(event);
            }
          };
          for (var method in instance) API.prototype[method] = instance[method];
          for (var key in EventTarget) API.prototype[key] = EventTarget[key];
          module2.exports = API;
        },
        /***/
        859(module2) {
          var Event = function(eventType, options) {
            this.type = eventType;
            for (var key in options)
              this[key] = options[key];
          };
          Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
            this.type = eventType;
            this.bubbles = canBubble;
            this.cancelable = cancelable;
          };
          Event.prototype.stopPropagation = function() {
          };
          Event.prototype.preventDefault = function() {
          };
          Event.CAPTURING_PHASE = 1;
          Event.AT_TARGET = 2;
          Event.BUBBLING_PHASE = 3;
          module2.exports = Event;
        },
        /***/
        667(module2, __unused_webpack_exports, __webpack_require__2) {
          var Event = __webpack_require__2(859);
          var EventTarget = {
            onopen: null,
            onmessage: null,
            onerror: null,
            onclose: null,
            addEventListener: function(eventType, listener, useCapture) {
              this.on(eventType, listener);
            },
            removeEventListener: function(eventType, listener, useCapture) {
              this.removeListener(eventType, listener);
            },
            dispatchEvent: function(event) {
              event.target = event.currentTarget = this;
              event.eventPhase = Event.AT_TARGET;
              if (this["on" + event.type])
                this["on" + event.type](event);
              this.emit(event.type, event);
            }
          };
          module2.exports = EventTarget;
        },
        /***/
        333(module2, __unused_webpack_exports, __webpack_require__2) {
          var util = __webpack_require__2(23), net = __webpack_require__2(278), tls = __webpack_require__2(756), url = __webpack_require__2(16), driver = __webpack_require__2(41), API = __webpack_require__2(720);
          __webpack_require__2(859);
          var DEFAULT_PORTS = { "http:": 80, "https:": 443, "ws:": 80, "wss:": 443 }, SECURE_PROTOCOLS = ["https:", "wss:"];
          var Client = function(_url, protocols, options) {
            options = options || {};
            this.url = _url;
            this._driver = driver.client(this.url, { maxLength: options.maxLength, protocols });
            ["open", "error"].forEach(function(event) {
              this._driver.on(event, function() {
                self2.headers = self2._driver.headers;
                self2.statusCode = self2._driver.statusCode;
              });
            }, this);
            var proxy = options.proxy || {}, endpoint = url.parse(proxy.origin || this.url), port = endpoint.port || DEFAULT_PORTS[endpoint.protocol], secure = SECURE_PROTOCOLS.indexOf(endpoint.protocol) >= 0, onConnect = function() {
              self2._onConnect();
            }, netOptions = options.net || {}, originTLS = options.tls || {}, socketTLS = proxy.origin ? proxy.tls || {} : originTLS, self2 = this;
            netOptions.host = socketTLS.host = endpoint.hostname;
            netOptions.port = socketTLS.port = port;
            originTLS.ca = originTLS.ca || options.ca;
            socketTLS.servername = socketTLS.servername || endpoint.hostname;
            this._stream = secure ? tls.connect(socketTLS, onConnect) : net.connect(netOptions, onConnect);
            if (proxy.origin) this._configureProxy(proxy, originTLS);
            API.call(this, options);
          };
          util.inherits(Client, API);
          Client.prototype._onConnect = function() {
            var worker = this._proxy || this._driver;
            worker.start();
          };
          Client.prototype._configureProxy = function(proxy, originTLS) {
            var uri = url.parse(this.url), secure = SECURE_PROTOCOLS.indexOf(uri.protocol) >= 0, self2 = this, name;
            this._proxy = this._driver.proxy(proxy.origin);
            if (proxy.headers) {
              for (name in proxy.headers) this._proxy.setHeader(name, proxy.headers[name]);
            }
            this._proxy.pipe(this._stream, { end: false });
            this._stream.pipe(this._proxy);
            this._proxy.on("connect", function() {
              if (secure) {
                var options = { socket: self2._stream, servername: uri.hostname };
                for (name in originTLS) options[name] = originTLS[name];
                self2._stream = tls.connect(options);
                self2._configureStream();
              }
              self2._driver.io.pipe(self2._stream);
              self2._stream.pipe(self2._driver.io);
              self2._driver.start();
            });
            this._proxy.on("error", function(error) {
              self2._driver.emit("error", error);
            });
          };
          module2.exports = Client;
        },
        /***/
        895(__unused_webpack_module, exports$1, __webpack_require__2) {
          var assert = __webpack_require__2(613);
          exports$1.e = HTTPParser;
          function HTTPParser(type) {
            assert.ok(type === HTTPParser.REQUEST || type === HTTPParser.RESPONSE || type === void 0);
            if (type === void 0) ;
            else {
              this.initialize(type);
            }
            this.maxHeaderSize = HTTPParser.maxHeaderSize;
          }
          HTTPParser.prototype.initialize = function(type, async_resource) {
            assert.ok(type === HTTPParser.REQUEST || type === HTTPParser.RESPONSE);
            this.type = type;
            this.state = type + "_LINE";
            this.info = {
              headers: [],
              upgrade: false
            };
            this.trailers = [];
            this.line = "";
            this.isChunked = false;
            this.connection = "";
            this.headerSize = 0;
            this.body_bytes = null;
            this.isUserCall = false;
            this.hadError = false;
          };
          HTTPParser.encoding = "ascii";
          HTTPParser.maxHeaderSize = 80 * 1024;
          HTTPParser.REQUEST = "REQUEST";
          HTTPParser.RESPONSE = "RESPONSE";
          var kOnHeaders = HTTPParser.kOnHeaders = 1;
          var kOnHeadersComplete = HTTPParser.kOnHeadersComplete = 2;
          var kOnBody = HTTPParser.kOnBody = 3;
          var kOnMessageComplete = HTTPParser.kOnMessageComplete = 4;
          HTTPParser.prototype[kOnHeaders] = HTTPParser.prototype[kOnHeadersComplete] = HTTPParser.prototype[kOnBody] = HTTPParser.prototype[kOnMessageComplete] = function() {
          };
          var compatMode0_12 = true;
          Object.defineProperty(HTTPParser, "kOnExecute", {
            get: function() {
              compatMode0_12 = false;
              return 99;
            }
          });
          var methods = HTTPParser.methods = [
            "DELETE",
            "GET",
            "HEAD",
            "POST",
            "PUT",
            "CONNECT",
            "OPTIONS",
            "TRACE",
            "COPY",
            "LOCK",
            "MKCOL",
            "MOVE",
            "PROPFIND",
            "PROPPATCH",
            "SEARCH",
            "UNLOCK",
            "BIND",
            "REBIND",
            "UNBIND",
            "ACL",
            "REPORT",
            "MKACTIVITY",
            "CHECKOUT",
            "MERGE",
            "M-SEARCH",
            "NOTIFY",
            "SUBSCRIBE",
            "UNSUBSCRIBE",
            "PATCH",
            "PURGE",
            "MKCALENDAR",
            "LINK",
            "UNLINK",
            "SOURCE"
          ];
          var method_connect = methods.indexOf("CONNECT");
          HTTPParser.prototype.reinitialize = HTTPParser;
          HTTPParser.prototype.close = HTTPParser.prototype.pause = HTTPParser.prototype.resume = HTTPParser.prototype.free = function() {
          };
          HTTPParser.prototype._compatMode0_11 = false;
          HTTPParser.prototype.getAsyncId = function() {
            return 0;
          };
          var headerState = {
            REQUEST_LINE: true,
            RESPONSE_LINE: true,
            HEADER: true
          };
          HTTPParser.prototype.execute = function(chunk, start, length) {
            if (!(this instanceof HTTPParser)) {
              throw new TypeError("not a HTTPParser");
            }
            start = start || 0;
            length = typeof length === "number" ? length : chunk.length;
            this.chunk = chunk;
            this.offset = start;
            var end = this.end = start + length;
            try {
              while (this.offset < end) {
                if (this[this.state]()) {
                  break;
                }
              }
            } catch (err) {
              if (this.isUserCall) {
                throw err;
              }
              this.hadError = true;
              return err;
            }
            this.chunk = null;
            length = this.offset - start;
            if (headerState[this.state]) {
              this.headerSize += length;
              if (this.headerSize > (this.maxHeaderSize || HTTPParser.maxHeaderSize)) {
                return new Error("max header size exceeded");
              }
            }
            return length;
          };
          var stateFinishAllowed = {
            REQUEST_LINE: true,
            RESPONSE_LINE: true,
            BODY_RAW: true
          };
          HTTPParser.prototype.finish = function() {
            if (this.hadError) {
              return;
            }
            if (!stateFinishAllowed[this.state]) {
              return new Error("invalid state for EOF");
            }
            if (this.state === "BODY_RAW") {
              this.userCall()(this[kOnMessageComplete]());
            }
          };
          HTTPParser.prototype.consume = HTTPParser.prototype.unconsume = HTTPParser.prototype.getCurrentBuffer = function() {
          };
          HTTPParser.prototype.userCall = function() {
            this.isUserCall = true;
            var self2 = this;
            return function(ret) {
              self2.isUserCall = false;
              return ret;
            };
          };
          HTTPParser.prototype.nextRequest = function() {
            this.userCall()(this[kOnMessageComplete]());
            this.reinitialize(this.type);
          };
          HTTPParser.prototype.consumeLine = function() {
            var end = this.end, chunk = this.chunk;
            for (var i = this.offset; i < end; i++) {
              if (chunk[i] === 10) {
                var line = this.line + chunk.toString(HTTPParser.encoding, this.offset, i);
                if (line.charAt(line.length - 1) === "\r") {
                  line = line.substr(0, line.length - 1);
                }
                this.line = "";
                this.offset = i + 1;
                return line;
              }
            }
            this.line += chunk.toString(HTTPParser.encoding, this.offset, this.end);
            this.offset = this.end;
          };
          var headerExp = /^([^: \t]+):[ \t]*((?:.*[^ \t])|)/;
          var headerContinueExp = /^[ \t]+(.*[^ \t])/;
          HTTPParser.prototype.parseHeader = function(line, headers) {
            if (line.indexOf("\r") !== -1) {
              throw parseErrorCode("HPE_LF_EXPECTED");
            }
            var match = headerExp.exec(line);
            var k2 = match && match[1];
            if (k2) {
              headers.push(k2);
              headers.push(match[2]);
            } else {
              var matchContinue = headerContinueExp.exec(line);
              if (matchContinue && headers.length) {
                if (headers[headers.length - 1]) {
                  headers[headers.length - 1] += " ";
                }
                headers[headers.length - 1] += matchContinue[1];
              }
            }
          };
          var requestExp = /^([A-Z-]+) ([^ ]+) HTTP\/(\d)\.(\d)$/;
          HTTPParser.prototype.REQUEST_LINE = function() {
            var line = this.consumeLine();
            if (!line) {
              return;
            }
            var match = requestExp.exec(line);
            if (match === null) {
              throw parseErrorCode("HPE_INVALID_CONSTANT");
            }
            this.info.method = this._compatMode0_11 ? match[1] : methods.indexOf(match[1]);
            if (this.info.method === -1) {
              throw new Error("invalid request method");
            }
            this.info.url = match[2];
            this.info.versionMajor = +match[3];
            this.info.versionMinor = +match[4];
            this.body_bytes = 0;
            this.state = "HEADER";
          };
          var responseExp = /^HTTP\/(\d)\.(\d) (\d{3}) ?(.*)$/;
          HTTPParser.prototype.RESPONSE_LINE = function() {
            var line = this.consumeLine();
            if (!line) {
              return;
            }
            var match = responseExp.exec(line);
            if (match === null) {
              throw parseErrorCode("HPE_INVALID_CONSTANT");
            }
            this.info.versionMajor = +match[1];
            this.info.versionMinor = +match[2];
            var statusCode = this.info.statusCode = +match[3];
            this.info.statusMessage = match[4];
            if ((statusCode / 100 | 0) === 1 || statusCode === 204 || statusCode === 304) {
              this.body_bytes = 0;
            }
            this.state = "HEADER";
          };
          HTTPParser.prototype.shouldKeepAlive = function() {
            if (this.info.versionMajor > 0 && this.info.versionMinor > 0) {
              if (this.connection.indexOf("close") !== -1) {
                return false;
              }
            } else if (this.connection.indexOf("keep-alive") === -1) {
              return false;
            }
            if (this.body_bytes !== null || this.isChunked) {
              return true;
            }
            return false;
          };
          HTTPParser.prototype.HEADER = function() {
            var line = this.consumeLine();
            if (line === void 0) {
              return;
            }
            var info = this.info;
            if (line) {
              this.parseHeader(line, info.headers);
            } else {
              var headers = info.headers;
              var hasContentLength = false;
              var currentContentLengthValue;
              var hasUpgradeHeader = false;
              for (var i = 0; i < headers.length; i += 2) {
                switch (headers[i].toLowerCase()) {
                  case "transfer-encoding":
                    this.isChunked = headers[i + 1].toLowerCase() === "chunked";
                    break;
                  case "content-length":
                    currentContentLengthValue = +headers[i + 1];
                    if (hasContentLength) {
                      if (currentContentLengthValue !== this.body_bytes) {
                        throw parseErrorCode("HPE_UNEXPECTED_CONTENT_LENGTH");
                      }
                    } else {
                      hasContentLength = true;
                      this.body_bytes = currentContentLengthValue;
                    }
                    break;
                  case "connection":
                    this.connection += headers[i + 1].toLowerCase();
                    break;
                  case "upgrade":
                    hasUpgradeHeader = true;
                    break;
                }
              }
              if (this.isChunked && hasContentLength) {
                hasContentLength = false;
                this.body_bytes = null;
              }
              if (hasUpgradeHeader && this.connection.indexOf("upgrade") != -1) {
                info.upgrade = this.type === HTTPParser.REQUEST || info.statusCode === 101;
              } else {
                info.upgrade = info.method === method_connect;
              }
              if (this.isChunked && info.upgrade) {
                this.isChunked = false;
              }
              info.shouldKeepAlive = this.shouldKeepAlive();
              var skipBody;
              if (compatMode0_12) {
                skipBody = this.userCall()(this[kOnHeadersComplete](info));
              } else {
                skipBody = this.userCall()(this[kOnHeadersComplete](
                  info.versionMajor,
                  info.versionMinor,
                  info.headers,
                  info.method,
                  info.url,
                  info.statusCode,
                  info.statusMessage,
                  info.upgrade,
                  info.shouldKeepAlive
                ));
              }
              if (skipBody === 2) {
                this.nextRequest();
                return true;
              } else if (this.isChunked && !skipBody) {
                this.state = "BODY_CHUNKHEAD";
              } else if (skipBody || this.body_bytes === 0) {
                this.nextRequest();
                return info.upgrade;
              } else if (this.body_bytes === null) {
                this.state = "BODY_RAW";
              } else {
                this.state = "BODY_SIZED";
              }
            }
          };
          HTTPParser.prototype.BODY_CHUNKHEAD = function() {
            var line = this.consumeLine();
            if (line === void 0) {
              return;
            }
            this.body_bytes = parseInt(line, 16);
            if (!this.body_bytes) {
              this.state = "BODY_CHUNKTRAILERS";
            } else {
              this.state = "BODY_CHUNK";
            }
          };
          HTTPParser.prototype.BODY_CHUNK = function() {
            var length = Math.min(this.end - this.offset, this.body_bytes);
            this.userCall()(this[kOnBody](this.chunk, this.offset, length));
            this.offset += length;
            this.body_bytes -= length;
            if (!this.body_bytes) {
              this.state = "BODY_CHUNKEMPTYLINE";
            }
          };
          HTTPParser.prototype.BODY_CHUNKEMPTYLINE = function() {
            var line = this.consumeLine();
            if (line === void 0) {
              return;
            }
            assert.equal(line, "");
            this.state = "BODY_CHUNKHEAD";
          };
          HTTPParser.prototype.BODY_CHUNKTRAILERS = function() {
            var line = this.consumeLine();
            if (line === void 0) {
              return;
            }
            if (line) {
              this.parseHeader(line, this.trailers);
            } else {
              if (this.trailers.length) {
                this.userCall()(this[kOnHeaders](this.trailers, ""));
              }
              this.nextRequest();
            }
          };
          HTTPParser.prototype.BODY_RAW = function() {
            var length = this.end - this.offset;
            this.userCall()(this[kOnBody](this.chunk, this.offset, length));
            this.offset = this.end;
          };
          HTTPParser.prototype.BODY_SIZED = function() {
            var length = Math.min(this.end - this.offset, this.body_bytes);
            this.userCall()(this[kOnBody](this.chunk, this.offset, length));
            this.offset += length;
            this.body_bytes -= length;
            if (!this.body_bytes) {
              this.nextRequest();
            }
          };
          ["Headers", "HeadersComplete", "Body", "MessageComplete"].forEach(function(name) {
            var k2 = HTTPParser["kOn" + name];
            Object.defineProperty(HTTPParser.prototype, "on" + name, {
              get: function() {
                return this[k2];
              },
              set: function(to) {
                this._compatMode0_11 = true;
                method_connect = "CONNECT";
                return this[k2] = to;
              }
            });
          });
          function parseErrorCode(code) {
            var err = new Error("Parse Error");
            err.code = code;
            return err;
          }
        },
        /***/
        891(module2, exports$1, __webpack_require__2) {
          var buffer = __webpack_require__2(181);
          var Buffer2 = buffer.Buffer;
          function copyProps(src, dst) {
            for (var key in src) {
              dst[key] = src[key];
            }
          }
          if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
            module2.exports = buffer;
          } else {
            copyProps(buffer, exports$1);
            exports$1.Buffer = SafeBuffer;
          }
          function SafeBuffer(arg, encodingOrOffset, length) {
            return Buffer2(arg, encodingOrOffset, length);
          }
          copyProps(Buffer2, SafeBuffer);
          SafeBuffer.from = function(arg, encodingOrOffset, length) {
            if (typeof arg === "number") {
              throw new TypeError("Argument must not be a number");
            }
            return Buffer2(arg, encodingOrOffset, length);
          };
          SafeBuffer.alloc = function(size, fill, encoding) {
            if (typeof size !== "number") {
              throw new TypeError("Argument must be a number");
            }
            var buf = Buffer2(size);
            if (fill !== void 0) {
              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 Buffer2(size);
          };
          SafeBuffer.allocUnsafeSlow = function(size) {
            if (typeof size !== "number") {
              throw new TypeError("Argument must be a number");
            }
            return buffer.SlowBuffer(size);
          };
        },
        /***/
        601(module2, __unused_webpack_exports, __webpack_require__2) {
          (function(nacl) {
            var gf = function(init) {
              var i, r2 = new Float64Array(16);
              if (init) for (i = 0; i < init.length; i++) r2[i] = init[i];
              return r2;
            };
            var randombytes = function() {
              throw new Error("no PRNG");
            };
            var _0 = new Uint8Array(16);
            var _9 = new Uint8Array(32);
            _9[0] = 9;
            var gf0 = gf(), gf1 = gf([1]), _121665 = gf([56129, 1]), D = gf([30883, 4953, 19914, 30187, 55467, 16705, 2637, 112, 59544, 30585, 16505, 36039, 65139, 11119, 27886, 20995]), D2 = gf([61785, 9906, 39828, 60374, 45398, 33411, 5274, 224, 53552, 61171, 33010, 6542, 64743, 22239, 55772, 9222]), X = gf([54554, 36645, 11616, 51542, 42930, 38181, 51040, 26924, 56412, 64982, 57905, 49316, 21502, 52590, 14035, 8553]), Y = gf([26200, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214]), I = gf([41136, 18958, 6951, 50414, 58488, 44335, 6150, 12099, 55207, 15867, 153, 11085, 57099, 20417, 9344, 11139]);
            function ts64(x, i, h3, l2) {
              x[i] = h3 >> 24 & 255;
              x[i + 1] = h3 >> 16 & 255;
              x[i + 2] = h3 >> 8 & 255;
              x[i + 3] = h3 & 255;
              x[i + 4] = l2 >> 24 & 255;
              x[i + 5] = l2 >> 16 & 255;
              x[i + 6] = l2 >> 8 & 255;
              x[i + 7] = l2 & 255;
            }
            function vn(x, xi, y2, yi, n) {
              var i, d2 = 0;
              for (i = 0; i < n; i++) d2 |= x[xi + i] ^ y2[yi + i];
              return (1 & d2 - 1 >>> 8) - 1;
            }
            function crypto_verify_16(x, xi, y2, yi) {
              return vn(x, xi, y2, yi, 16);
            }
            function crypto_verify_32(x, xi, y2, yi) {
              return vn(x, xi, y2, yi, 32);
            }
            function core_salsa20(o2, p2, k2, c2) {
              var j0 = c2[0] & 255 | (c2[1] & 255) << 8 | (c2[2] & 255) << 16 | (c2[3] & 255) << 24, j1 = k2[0] & 255 | (k2[1] & 255) << 8 | (k2[2] & 255) << 16 | (k2[3] & 255) << 24, j2 = k2[4] & 255 | (k2[5] & 255) << 8 | (k2[6] & 255) << 16 | (k2[7] & 255) << 24, j3 = k2[8] & 255 | (k2[9] & 255) << 8 | (k2[10] & 255) << 16 | (k2[11] & 255) << 24, j4 = k2[12] & 255 | (k2[13] & 255) << 8 | (k2[14] & 255) << 16 | (k2[15] & 255) << 24, j5 = c2[4] & 255 | (c2[5] & 255) << 8 | (c2[6] & 255) << 16 | (c2[7] & 255) << 24, j6 = p2[0] & 255 | (p2[1] & 255) << 8 | (p2[2] & 255) << 16 | (p2[3] & 255) << 24, j7 = p2[4] & 255 | (p2[5] & 255) << 8 | (p2[6] & 255) << 16 | (p2[7] & 255) << 24, j8 = p2[8] & 255 | (p2[9] & 255) << 8 | (p2[10] & 255) << 16 | (p2[11] & 255) << 24, j9 = p2[12] & 255 | (p2[13] & 255) << 8 | (p2[14] & 255) << 16 | (p2[15] & 255) << 24, j10 = c2[8] & 255 | (c2[9] & 255) << 8 | (c2[10] & 255) << 16 | (c2[11] & 255) << 24, j11 = k2[16] & 255 | (k2[17] & 255) << 8 | (k2[18] & 255) << 16 | (k2[19] & 255) << 24, j12 = k2[20] & 255 | (k2[21] & 255) << 8 | (k2[22] & 255) << 16 | (k2[23] & 255) << 24, j13 = k2[24] & 255 | (k2[25] & 255) << 8 | (k2[26] & 255) << 16 | (k2[27] & 255) << 24, j14 = k2[28] & 255 | (k2[29] & 255) << 8 | (k2[30] & 255) << 16 | (k2[31] & 255) << 24, j15 = c2[12] & 255 | (c2[13] & 255) << 8 | (c2[14] & 255) << 16 | (c2[15] & 255) << 24;
              var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, x15 = j15, u2;
              for (var i = 0; i < 20; i += 2) {
                u2 = x0 + x12 | 0;
                x4 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x4 + x0 | 0;
                x8 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x8 + x4 | 0;
                x12 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x12 + x8 | 0;
                x0 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x5 + x1 | 0;
                x9 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x9 + x5 | 0;
                x13 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x13 + x9 | 0;
                x1 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x1 + x13 | 0;
                x5 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x10 + x6 | 0;
                x14 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x14 + x10 | 0;
                x2 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x2 + x14 | 0;
                x6 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x6 + x2 | 0;
                x10 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x15 + x11 | 0;
                x3 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x3 + x15 | 0;
                x7 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x7 + x3 | 0;
                x11 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x11 + x7 | 0;
                x15 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x0 + x3 | 0;
                x1 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x1 + x0 | 0;
                x2 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x2 + x1 | 0;
                x3 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x3 + x2 | 0;
                x0 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x5 + x4 | 0;
                x6 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x6 + x5 | 0;
                x7 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x7 + x6 | 0;
                x4 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x4 + x7 | 0;
                x5 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x10 + x9 | 0;
                x11 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x11 + x10 | 0;
                x8 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x8 + x11 | 0;
                x9 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x9 + x8 | 0;
                x10 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x15 + x14 | 0;
                x12 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x12 + x15 | 0;
                x13 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x13 + x12 | 0;
                x14 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x14 + x13 | 0;
                x15 ^= u2 << 18 | u2 >>> 32 - 18;
              }
              x0 = x0 + j0 | 0;
              x1 = x1 + j1 | 0;
              x2 = x2 + j2 | 0;
              x3 = x3 + j3 | 0;
              x4 = x4 + j4 | 0;
              x5 = x5 + j5 | 0;
              x6 = x6 + j6 | 0;
              x7 = x7 + j7 | 0;
              x8 = x8 + j8 | 0;
              x9 = x9 + j9 | 0;
              x10 = x10 + j10 | 0;
              x11 = x11 + j11 | 0;
              x12 = x12 + j12 | 0;
              x13 = x13 + j13 | 0;
              x14 = x14 + j14 | 0;
              x15 = x15 + j15 | 0;
              o2[0] = x0 >>> 0 & 255;
              o2[1] = x0 >>> 8 & 255;
              o2[2] = x0 >>> 16 & 255;
              o2[3] = x0 >>> 24 & 255;
              o2[4] = x1 >>> 0 & 255;
              o2[5] = x1 >>> 8 & 255;
              o2[6] = x1 >>> 16 & 255;
              o2[7] = x1 >>> 24 & 255;
              o2[8] = x2 >>> 0 & 255;
              o2[9] = x2 >>> 8 & 255;
              o2[10] = x2 >>> 16 & 255;
              o2[11] = x2 >>> 24 & 255;
              o2[12] = x3 >>> 0 & 255;
              o2[13] = x3 >>> 8 & 255;
              o2[14] = x3 >>> 16 & 255;
              o2[15] = x3 >>> 24 & 255;
              o2[16] = x4 >>> 0 & 255;
              o2[17] = x4 >>> 8 & 255;
              o2[18] = x4 >>> 16 & 255;
              o2[19] = x4 >>> 24 & 255;
              o2[20] = x5 >>> 0 & 255;
              o2[21] = x5 >>> 8 & 255;
              o2[22] = x5 >>> 16 & 255;
              o2[23] = x5 >>> 24 & 255;
              o2[24] = x6 >>> 0 & 255;
              o2[25] = x6 >>> 8 & 255;
              o2[26] = x6 >>> 16 & 255;
              o2[27] = x6 >>> 24 & 255;
              o2[28] = x7 >>> 0 & 255;
              o2[29] = x7 >>> 8 & 255;
              o2[30] = x7 >>> 16 & 255;
              o2[31] = x7 >>> 24 & 255;
              o2[32] = x8 >>> 0 & 255;
              o2[33] = x8 >>> 8 & 255;
              o2[34] = x8 >>> 16 & 255;
              o2[35] = x8 >>> 24 & 255;
              o2[36] = x9 >>> 0 & 255;
              o2[37] = x9 >>> 8 & 255;
              o2[38] = x9 >>> 16 & 255;
              o2[39] = x9 >>> 24 & 255;
              o2[40] = x10 >>> 0 & 255;
              o2[41] = x10 >>> 8 & 255;
              o2[42] = x10 >>> 16 & 255;
              o2[43] = x10 >>> 24 & 255;
              o2[44] = x11 >>> 0 & 255;
              o2[45] = x11 >>> 8 & 255;
              o2[46] = x11 >>> 16 & 255;
              o2[47] = x11 >>> 24 & 255;
              o2[48] = x12 >>> 0 & 255;
              o2[49] = x12 >>> 8 & 255;
              o2[50] = x12 >>> 16 & 255;
              o2[51] = x12 >>> 24 & 255;
              o2[52] = x13 >>> 0 & 255;
              o2[53] = x13 >>> 8 & 255;
              o2[54] = x13 >>> 16 & 255;
              o2[55] = x13 >>> 24 & 255;
              o2[56] = x14 >>> 0 & 255;
              o2[57] = x14 >>> 8 & 255;
              o2[58] = x14 >>> 16 & 255;
              o2[59] = x14 >>> 24 & 255;
              o2[60] = x15 >>> 0 & 255;
              o2[61] = x15 >>> 8 & 255;
              o2[62] = x15 >>> 16 & 255;
              o2[63] = x15 >>> 24 & 255;
            }
            function core_hsalsa20(o2, p2, k2, c2) {
              var j0 = c2[0] & 255 | (c2[1] & 255) << 8 | (c2[2] & 255) << 16 | (c2[3] & 255) << 24, j1 = k2[0] & 255 | (k2[1] & 255) << 8 | (k2[2] & 255) << 16 | (k2[3] & 255) << 24, j2 = k2[4] & 255 | (k2[5] & 255) << 8 | (k2[6] & 255) << 16 | (k2[7] & 255) << 24, j3 = k2[8] & 255 | (k2[9] & 255) << 8 | (k2[10] & 255) << 16 | (k2[11] & 255) << 24, j4 = k2[12] & 255 | (k2[13] & 255) << 8 | (k2[14] & 255) << 16 | (k2[15] & 255) << 24, j5 = c2[4] & 255 | (c2[5] & 255) << 8 | (c2[6] & 255) << 16 | (c2[7] & 255) << 24, j6 = p2[0] & 255 | (p2[1] & 255) << 8 | (p2[2] & 255) << 16 | (p2[3] & 255) << 24, j7 = p2[4] & 255 | (p2[5] & 255) << 8 | (p2[6] & 255) << 16 | (p2[7] & 255) << 24, j8 = p2[8] & 255 | (p2[9] & 255) << 8 | (p2[10] & 255) << 16 | (p2[11] & 255) << 24, j9 = p2[12] & 255 | (p2[13] & 255) << 8 | (p2[14] & 255) << 16 | (p2[15] & 255) << 24, j10 = c2[8] & 255 | (c2[9] & 255) << 8 | (c2[10] & 255) << 16 | (c2[11] & 255) << 24, j11 = k2[16] & 255 | (k2[17] & 255) << 8 | (k2[18] & 255) << 16 | (k2[19] & 255) << 24, j12 = k2[20] & 255 | (k2[21] & 255) << 8 | (k2[22] & 255) << 16 | (k2[23] & 255) << 24, j13 = k2[24] & 255 | (k2[25] & 255) << 8 | (k2[26] & 255) << 16 | (k2[27] & 255) << 24, j14 = k2[28] & 255 | (k2[29] & 255) << 8 | (k2[30] & 255) << 16 | (k2[31] & 255) << 24, j15 = c2[12] & 255 | (c2[13] & 255) << 8 | (c2[14] & 255) << 16 | (c2[15] & 255) << 24;
              var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, x15 = j15, u2;
              for (var i = 0; i < 20; i += 2) {
                u2 = x0 + x12 | 0;
                x4 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x4 + x0 | 0;
                x8 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x8 + x4 | 0;
                x12 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x12 + x8 | 0;
                x0 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x5 + x1 | 0;
                x9 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x9 + x5 | 0;
                x13 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x13 + x9 | 0;
                x1 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x1 + x13 | 0;
                x5 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x10 + x6 | 0;
                x14 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x14 + x10 | 0;
                x2 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x2 + x14 | 0;
                x6 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x6 + x2 | 0;
                x10 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x15 + x11 | 0;
                x3 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x3 + x15 | 0;
                x7 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x7 + x3 | 0;
                x11 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x11 + x7 | 0;
                x15 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x0 + x3 | 0;
                x1 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x1 + x0 | 0;
                x2 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x2 + x1 | 0;
                x3 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x3 + x2 | 0;
                x0 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x5 + x4 | 0;
                x6 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x6 + x5 | 0;
                x7 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x7 + x6 | 0;
                x4 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x4 + x7 | 0;
                x5 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x10 + x9 | 0;
                x11 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x11 + x10 | 0;
                x8 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x8 + x11 | 0;
                x9 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x9 + x8 | 0;
                x10 ^= u2 << 18 | u2 >>> 32 - 18;
                u2 = x15 + x14 | 0;
                x12 ^= u2 << 7 | u2 >>> 32 - 7;
                u2 = x12 + x15 | 0;
                x13 ^= u2 << 9 | u2 >>> 32 - 9;
                u2 = x13 + x12 | 0;
                x14 ^= u2 << 13 | u2 >>> 32 - 13;
                u2 = x14 + x13 | 0;
                x15 ^= u2 << 18 | u2 >>> 32 - 18;
              }
              o2[0] = x0 >>> 0 & 255;
              o2[1] = x0 >>> 8 & 255;
              o2[2] = x0 >>> 16 & 255;
              o2[3] = x0 >>> 24 & 255;
              o2[4] = x5 >>> 0 & 255;
              o2[5] = x5 >>> 8 & 255;
              o2[6] = x5 >>> 16 & 255;
              o2[7] = x5 >>> 24 & 255;
              o2[8] = x10 >>> 0 & 255;
              o2[9] = x10 >>> 8 & 255;
              o2[10] = x10 >>> 16 & 255;
              o2[11] = x10 >>> 24 & 255;
              o2[12] = x15 >>> 0 & 255;
              o2[13] = x15 >>> 8 & 255;
              o2[14] = x15 >>> 16 & 255;
              o2[15] = x15 >>> 24 & 255;
              o2[16] = x6 >>> 0 & 255;
              o2[17] = x6 >>> 8 & 255;
              o2[18] = x6 >>> 16 & 255;
              o2[19] = x6 >>> 24 & 255;
              o2[20] = x7 >>> 0 & 255;
              o2[21] = x7 >>> 8 & 255;
              o2[22] = x7 >>> 16 & 255;
              o2[23] = x7 >>> 24 & 255;
              o2[24] = x8 >>> 0 & 255;
              o2[25] = x8 >>> 8 & 255;
              o2[26] = x8 >>> 16 & 255;
              o2[27] = x8 >>> 24 & 255;
              o2[28] = x9 >>> 0 & 255;
              o2[29] = x9 >>> 8 & 255;
              o2[30] = x9 >>> 16 & 255;
              o2[31] = x9 >>> 24 & 255;
            }
            function crypto_core_salsa20(out, inp, k2, c2) {
              core_salsa20(out, inp, k2, c2);
            }
            function crypto_core_hsalsa20(out, inp, k2, c2) {
              core_hsalsa20(out, inp, k2, c2);
            }
            var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
            function crypto_stream_salsa20_xor(c2, cpos, m2, mpos, b2, n, k2) {
              var z = new Uint8Array(16), x = new Uint8Array(64);
              var u2, i;
              for (i = 0; i < 16; i++) z[i] = 0;
              for (i = 0; i < 8; i++) z[i] = n[i];
              while (b2 >= 64) {
                crypto_core_salsa20(x, z, k2, sigma);
                for (i = 0; i < 64; i++) c2[cpos + i] = m2[mpos + i] ^ x[i];
                u2 = 1;
                for (i = 8; i < 16; i++) {
                  u2 = u2 + (z[i] & 255) | 0;
                  z[i] = u2 & 255;
                  u2 >>>= 8;
                }
                b2 -= 64;
                cpos += 64;
                mpos += 64;
              }
              if (b2 > 0) {
                crypto_core_salsa20(x, z, k2, sigma);
                for (i = 0; i < b2; i++) c2[cpos + i] = m2[mpos + i] ^ x[i];
              }
              return 0;
            }
            function crypto_stream_salsa20(c2, cpos, b2, n, k2) {
              var z = new Uint8Array(16), x = new Uint8Array(64);
              var u2, i;
              for (i = 0; i < 16; i++) z[i] = 0;
              for (i = 0; i < 8; i++) z[i] = n[i];
              while (b2 >= 64) {
                crypto_core_salsa20(x, z, k2, sigma);
                for (i = 0; i < 64; i++) c2[cpos + i] = x[i];
                u2 = 1;
                for (i = 8; i < 16; i++) {
                  u2 = u2 + (z[i] & 255) | 0;
                  z[i] = u2 & 255;
                  u2 >>>= 8;
                }
                b2 -= 64;
                cpos += 64;
              }
              if (b2 > 0) {
                crypto_core_salsa20(x, z, k2, sigma);
                for (i = 0; i < b2; i++) c2[cpos + i] = x[i];
              }
              return 0;
            }
            function crypto_stream(c2, cpos, d2, n, k2) {
              var s = new Uint8Array(32);
              crypto_core_hsalsa20(s, n, k2, sigma);
              var sn = new Uint8Array(8);
              for (var i = 0; i < 8; i++) sn[i] = n[i + 16];
              return crypto_stream_salsa20(c2, cpos, d2, sn, s);
            }
            function crypto_stream_xor(c2, cpos, m2, mpos, d2, n, k2) {
              var s = new Uint8Array(32);
              crypto_core_hsalsa20(s, n, k2, sigma);
              var sn = new Uint8Array(8);
              for (var i = 0; i < 8; i++) sn[i] = n[i + 16];
              return crypto_stream_salsa20_xor(c2, cpos, m2, mpos, d2, sn, s);
            }
            var poly1305 = function(key) {
              this.buffer = new Uint8Array(16);
              this.r = new Uint16Array(10);
              this.h = new Uint16Array(10);
              this.pad = new Uint16Array(8);
              this.leftover = 0;
              this.fin = 0;
              var t0, t1, t2, t3, t4, t5, t6, t7;
              t0 = key[0] & 255 | (key[1] & 255) << 8;
              this.r[0] = t0 & 8191;
              t1 = key[2] & 255 | (key[3] & 255) << 8;
              this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
              t2 = key[4] & 255 | (key[5] & 255) << 8;
              this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
              t3 = key[6] & 255 | (key[7] & 255) << 8;
              this.r[3] = (t2 >>> 7 | t3 << 9) & 8191;
              t4 = key[8] & 255 | (key[9] & 255) << 8;
              this.r[4] = (t3 >>> 4 | t4 << 12) & 255;
              this.r[5] = t4 >>> 1 & 8190;
              t5 = key[10] & 255 | (key[11] & 255) << 8;
              this.r[6] = (t4 >>> 14 | t5 << 2) & 8191;
              t6 = key[12] & 255 | (key[13] & 255) << 8;
              this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
              t7 = key[14] & 255 | (key[15] & 255) << 8;
              this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
              this.r[9] = t7 >>> 5 & 127;
              this.pad[0] = key[16] & 255 | (key[17] & 255) << 8;
              this.pad[1] = key[18] & 255 | (key[19] & 255) << 8;
              this.pad[2] = key[20] & 255 | (key[21] & 255) << 8;
              this.pad[3] = key[22] & 255 | (key[23] & 255) << 8;
              this.pad[4] = key[24] & 255 | (key[25] & 255) << 8;
              this.pad[5] = key[26] & 255 | (key[27] & 255) << 8;
              this.pad[6] = key[28] & 255 | (key[29] & 255) << 8;
              this.pad[7] = key[30] & 255 | (key[31] & 255) << 8;
            };
            poly1305.prototype.blocks = function(m2, mpos, bytes) {
              var hibit = this.fin ? 0 : 1 << 11;
              var t0, t1, t2, t3, t4, t5, t6, t7, c2;
              var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9;
              var h0 = this.h[0], h1 = this.h[1], h22 = this.h[2], h3 = this.h[3], h4 = this.h[4], h5 = this.h[5], h6 = this.h[6], h7 = this.h[7], h8 = this.h[8], h9 = this.h[9];
              var r0 = this.r[0], r1 = this.r[1], r2 = this.r[2], r3 = this.r[3], r4 = this.r[4], r5 = this.r[5], r6 = this.r[6], r7 = this.r[7], r8 = this.r[8], r9 = this.r[9];
              while (bytes >= 16) {
                t0 = m2[mpos + 0] & 255 | (m2[mpos + 1] & 255) << 8;
                h0 += t0 & 8191;
                t1 = m2[mpos + 2] & 255 | (m2[mpos + 3] & 255) << 8;
                h1 += (t0 >>> 13 | t1 << 3) & 8191;
                t2 = m2[mpos + 4] & 255 | (m2[mpos + 5] & 255) << 8;
                h22 += (t1 >>> 10 | t2 << 6) & 8191;
                t3 = m2[mpos + 6] & 255 | (m2[mpos + 7] & 255) << 8;
                h3 += (t2 >>> 7 | t3 << 9) & 8191;
                t4 = m2[mpos + 8] & 255 | (m2[mpos + 9] & 255) << 8;
                h4 += (t3 >>> 4 | t4 << 12) & 8191;
                h5 += t4 >>> 1 & 8191;
                t5 = m2[mpos + 10] & 255 | (m2[mpos + 11] & 255) << 8;
                h6 += (t4 >>> 14 | t5 << 2) & 8191;
                t6 = m2[mpos + 12] & 255 | (m2[mpos + 13] & 255) << 8;
                h7 += (t5 >>> 11 | t6 << 5) & 8191;
                t7 = m2[mpos + 14] & 255 | (m2[mpos + 15] & 255) << 8;
                h8 += (t6 >>> 8 | t7 << 8) & 8191;
                h9 += t7 >>> 5 | hibit;
                c2 = 0;
                d0 = c2;
                d0 += h0 * r0;
                d0 += h1 * (5 * r9);
                d0 += h22 * (5 * r8);
                d0 += h3 * (5 * r7);
                d0 += h4 * (5 * r6);
                c2 = d0 >>> 13;
                d0 &= 8191;
                d0 += h5 * (5 * r5);
                d0 += h6 * (5 * r4);
                d0 += h7 * (5 * r3);
                d0 += h8 * (5 * r2);
                d0 += h9 * (5 * r1);
                c2 += d0 >>> 13;
                d0 &= 8191;
                d1 = c2;
                d1 += h0 * r1;
                d1 += h1 * r0;
                d1 += h22 * (5 * r9);
                d1 += h3 * (5 * r8);
                d1 += h4 * (5 * r7);
                c2 = d1 >>> 13;
                d1 &= 8191;
                d1 += h5 * (5 * r6);
                d1 += h6 * (5 * r5);
                d1 += h7 * (5 * r4);
                d1 += h8 * (5 * r3);
                d1 += h9 * (5 * r2);
                c2 += d1 >>> 13;
                d1 &= 8191;
                d2 = c2;
                d2 += h0 * r2;
                d2 += h1 * r1;
                d2 += h22 * r0;
                d2 += h3 * (5 * r9);
                d2 += h4 * (5 * r8);
                c2 = d2 >>> 13;
                d2 &= 8191;
                d2 += h5 * (5 * r7);
                d2 += h6 * (5 * r6);
                d2 += h7 * (5 * r5);
                d2 += h8 * (5 * r4);
                d2 += h9 * (5 * r3);
                c2 += d2 >>> 13;
                d2 &= 8191;
                d3 = c2;
                d3 += h0 * r3;
                d3 += h1 * r2;
                d3 += h22 * r1;
                d3 += h3 * r0;
                d3 += h4 * (5 * r9);
                c2 = d3 >>> 13;
                d3 &= 8191;
                d3 += h5 * (5 * r8);
                d3 += h6 * (5 * r7);
                d3 += h7 * (5 * r6);
                d3 += h8 * (5 * r5);
                d3 += h9 * (5 * r4);
                c2 += d3 >>> 13;
                d3 &= 8191;
                d4 = c2;
                d4 += h0 * r4;
                d4 += h1 * r3;
                d4 += h22 * r2;
                d4 += h3 * r1;
                d4 += h4 * r0;
                c2 = d4 >>> 13;
                d4 &= 8191;
                d4 += h5 * (5 * r9);
                d4 += h6 * (5 * r8);
                d4 += h7 * (5 * r7);
                d4 += h8 * (5 * r6);
                d4 += h9 * (5 * r5);
                c2 += d4 >>> 13;
                d4 &= 8191;
                d5 = c2;
                d5 += h0 * r5;
                d5 += h1 * r4;
                d5 += h22 * r3;
                d5 += h3 * r2;
                d5 += h4 * r1;
                c2 = d5 >>> 13;
                d5 &= 8191;
                d5 += h5 * r0;
                d5 += h6 * (5 * r9);
                d5 += h7 * (5 * r8);
                d5 += h8 * (5 * r7);
                d5 += h9 * (5 * r6);
                c2 += d5 >>> 13;
                d5 &= 8191;
                d6 = c2;
                d6 += h0 * r6;
                d6 += h1 * r5;
                d6 += h22 * r4;
                d6 += h3 * r3;
                d6 += h4 * r2;
                c2 = d6 >>> 13;
                d6 &= 8191;
                d6 += h5 * r1;
                d6 += h6 * r0;
                d6 += h7 * (5 * r9);
                d6 += h8 * (5 * r8);
                d6 += h9 * (5 * r7);
                c2 += d6 >>> 13;
                d6 &= 8191;
                d7 = c2;
                d7 += h0 * r7;
                d7 += h1 * r6;
                d7 += h22 * r5;
                d7 += h3 * r4;
                d7 += h4 * r3;
                c2 = d7 >>> 13;
                d7 &= 8191;
                d7 += h5 * r2;
                d7 += h6 * r1;
                d7 += h7 * r0;
                d7 += h8 * (5 * r9);
                d7 += h9 * (5 * r8);
                c2 += d7 >>> 13;
                d7 &= 8191;
                d8 = c2;
                d8 += h0 * r8;
                d8 += h1 * r7;
                d8 += h22 * r6;
                d8 += h3 * r5;
                d8 += h4 * r4;
                c2 = d8 >>> 13;
                d8 &= 8191;
                d8 += h5 * r3;
                d8 += h6 * r2;
                d8 += h7 * r1;
                d8 += h8 * r0;
                d8 += h9 * (5 * r9);
                c2 += d8 >>> 13;
                d8 &= 8191;
                d9 = c2;
                d9 += h0 * r9;
                d9 += h1 * r8;
                d9 += h22 * r7;
                d9 += h3 * r6;
                d9 += h4 * r5;
                c2 = d9 >>> 13;
                d9 &= 8191;
                d9 += h5 * r4;
                d9 += h6 * r3;
                d9 += h7 * r2;
                d9 += h8 * r1;
                d9 += h9 * r0;
                c2 += d9 >>> 13;
                d9 &= 8191;
                c2 = (c2 << 2) + c2 | 0;
                c2 = c2 + d0 | 0;
                d0 = c2 & 8191;
                c2 = c2 >>> 13;
                d1 += c2;
                h0 = d0;
                h1 = d1;
                h22 = d2;
                h3 = d3;
                h4 = d4;
                h5 = d5;
                h6 = d6;
                h7 = d7;
                h8 = d8;
                h9 = d9;
                mpos += 16;
                bytes -= 16;
              }
              this.h[0] = h0;
              this.h[1] = h1;
              this.h[2] = h22;
              this.h[3] = h3;
              this.h[4] = h4;
              this.h[5] = h5;
              this.h[6] = h6;
              this.h[7] = h7;
              this.h[8] = h8;
              this.h[9] = h9;
            };
            poly1305.prototype.finish = function(mac, macpos) {
              var g2 = new Uint16Array(10);
              var c2, mask, f2, i;
              if (this.leftover) {
                i = this.leftover;
                this.buffer[i++] = 1;
                for (; i < 16; i++) this.buffer[i] = 0;
                this.fin = 1;
                this.blocks(this.buffer, 0, 16);
              }
              c2 = this.h[1] >>> 13;
              this.h[1] &= 8191;
              for (i = 2; i < 10; i++) {
                this.h[i] += c2;
                c2 = this.h[i] >>> 13;
                this.h[i] &= 8191;
              }
              this.h[0] += c2 * 5;
              c2 = this.h[0] >>> 13;
              this.h[0] &= 8191;
              this.h[1] += c2;
              c2 = this.h[1] >>> 13;
              this.h[1] &= 8191;
              this.h[2] += c2;
              g2[0] = this.h[0] + 5;
              c2 = g2[0] >>> 13;
              g2[0] &= 8191;
              for (i = 1; i < 10; i++) {
                g2[i] = this.h[i] + c2;
                c2 = g2[i] >>> 13;
                g2[i] &= 8191;
              }
              g2[9] -= 1 << 13;
              mask = (c2 ^ 1) - 1;
              for (i = 0; i < 10; i++) g2[i] &= mask;
              mask = ~mask;
              for (i = 0; i < 10; i++) this.h[i] = this.h[i] & mask | g2[i];
              this.h[0] = (this.h[0] | this.h[1] << 13) & 65535;
              this.h[1] = (this.h[1] >>> 3 | this.h[2] << 10) & 65535;
              this.h[2] = (this.h[2] >>> 6 | this.h[3] << 7) & 65535;
              this.h[3] = (this.h[3] >>> 9 | this.h[4] << 4) & 65535;
              this.h[4] = (this.h[4] >>> 12 | this.h[5] << 1 | this.h[6] << 14) & 65535;
              this.h[5] = (this.h[6] >>> 2 | this.h[7] << 11) & 65535;
              this.h[6] = (this.h[7] >>> 5 | this.h[8] << 8) & 65535;
              this.h[7] = (this.h[8] >>> 8 | this.h[9] << 5) & 65535;
              f2 = this.h[0] + this.pad[0];
              this.h[0] = f2 & 65535;
              for (i = 1; i < 8; i++) {
                f2 = (this.h[i] + this.pad[i] | 0) + (f2 >>> 16) | 0;
                this.h[i] = f2 & 65535;
              }
              mac[macpos + 0] = this.h[0] >>> 0 & 255;
              mac[macpos + 1] = this.h[0] >>> 8 & 255;
              mac[macpos + 2] = this.h[1] >>> 0 & 255;
              mac[macpos + 3] = this.h[1] >>> 8 & 255;
              mac[macpos + 4] = this.h[2] >>> 0 & 255;
              mac[macpos + 5] = this.h[2] >>> 8 & 255;
              mac[macpos + 6] = this.h[3] >>> 0 & 255;
              mac[macpos + 7] = this.h[3] >>> 8 & 255;
              mac[macpos + 8] = this.h[4] >>> 0 & 255;
              mac[macpos + 9] = this.h[4] >>> 8 & 255;
              mac[macpos + 10] = this.h[5] >>> 0 & 255;
              mac[macpos + 11] = this.h[5] >>> 8 & 255;
              mac[macpos + 12] = this.h[6] >>> 0 & 255;
              mac[macpos + 13] = this.h[6] >>> 8 & 255;
              mac[macpos + 14] = this.h[7] >>> 0 & 255;
              mac[macpos + 15] = this.h[7] >>> 8 & 255;
            };
            poly1305.prototype.update = function(m2, mpos, bytes) {
              var i, want;
              if (this.leftover) {
                want = 16 - this.leftover;
                if (want > bytes)
                  want = bytes;
                for (i = 0; i < want; i++)
                  this.buffer[this.leftover + i] = m2[mpos + i];
                bytes -= want;
                mpos += want;
                this.leftover += want;
                if (this.leftover < 16)
                  return;
                this.blocks(this.buffer, 0, 16);
                this.leftover = 0;
              }
              if (bytes >= 16) {
                want = bytes - bytes % 16;
                this.blocks(m2, mpos, want);
                mpos += want;
                bytes -= want;
              }
              if (bytes) {
                for (i = 0; i < bytes; i++)
                  this.buffer[this.leftover + i] = m2[mpos + i];
                this.leftover += bytes;
              }
            };
            function crypto_onetimeauth(out, outpos, m2, mpos, n, k2) {
              var s = new poly1305(k2);
              s.update(m2, mpos, n);
              s.finish(out, outpos);
              return 0;
            }
            function crypto_onetimeauth_verify(h3, hpos, m2, mpos, n, k2) {
              var x = new Uint8Array(16);
              crypto_onetimeauth(x, 0, m2, mpos, n, k2);
              return crypto_verify_16(h3, hpos, x, 0);
            }
            function crypto_secretbox(c2, m2, d2, n, k2) {
              var i;
              if (d2 < 32) return -1;
              crypto_stream_xor(c2, 0, m2, 0, d2, n, k2);
              crypto_onetimeauth(c2, 16, c2, 32, d2 - 32, c2);
              for (i = 0; i < 16; i++) c2[i] = 0;
              return 0;
            }
            function crypto_secretbox_open(m2, c2, d2, n, k2) {
              var i;
              var x = new Uint8Array(32);
              if (d2 < 32) return -1;
              crypto_stream(x, 0, 32, n, k2);
              if (crypto_onetimeauth_verify(c2, 16, c2, 32, d2 - 32, x) !== 0) return -1;
              crypto_stream_xor(m2, 0, c2, 0, d2, n, k2);
              for (i = 0; i < 32; i++) m2[i] = 0;
              return 0;
            }
            function set25519(r2, a) {
              var i;
              for (i = 0; i < 16; i++) r2[i] = a[i] | 0;
            }
            function car25519(o2) {
              var i, v2, c2 = 1;
              for (i = 0; i < 16; i++) {
                v2 = o2[i] + c2 + 65535;
                c2 = Math.floor(v2 / 65536);
                o2[i] = v2 - c2 * 65536;
              }
              o2[0] += c2 - 1 + 37 * (c2 - 1);
            }
            function sel25519(p2, q, b2) {
              var t, c2 = ~(b2 - 1);
              for (var i = 0; i < 16; i++) {
                t = c2 & (p2[i] ^ q[i]);
                p2[i] ^= t;
                q[i] ^= t;
              }
            }
            function pack25519(o2, n) {
              var i, j, b2;
              var m2 = gf(), t = gf();
              for (i = 0; i < 16; i++) t[i] = n[i];
              car25519(t);
              car25519(t);
              car25519(t);
              for (j = 0; j < 2; j++) {
                m2[0] = t[0] - 65517;
                for (i = 1; i < 15; i++) {
                  m2[i] = t[i] - 65535 - (m2[i - 1] >> 16 & 1);
                  m2[i - 1] &= 65535;
                }
                m2[15] = t[15] - 32767 - (m2[14] >> 16 & 1);
                b2 = m2[15] >> 16 & 1;
                m2[14] &= 65535;
                sel25519(t, m2, 1 - b2);
              }
              for (i = 0; i < 16; i++) {
                o2[2 * i] = t[i] & 255;
                o2[2 * i + 1] = t[i] >> 8;
              }
            }
            function neq25519(a, b2) {
              var c2 = new Uint8Array(32), d2 = new Uint8Array(32);
              pack25519(c2, a);
              pack25519(d2, b2);
              return crypto_verify_32(c2, 0, d2, 0);
            }
            function par25519(a) {
              var d2 = new Uint8Array(32);
              pack25519(d2, a);
              return d2[0] & 1;
            }
            function unpack25519(o2, n) {
              var i;
              for (i = 0; i < 16; i++) o2[i] = n[2 * i] + (n[2 * i + 1] << 8);
              o2[15] &= 32767;
            }
            function A(o2, a, b2) {
              for (var i = 0; i < 16; i++) o2[i] = a[i] + b2[i];
            }
            function Z(o2, a, b2) {
              for (var i = 0; i < 16; i++) o2[i] = a[i] - b2[i];
            }
            function M(o2, a, b2) {
              var v2, c2, t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0, b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3], b4 = b2[4], b5 = b2[5], b6 = b2[6], b7 = b2[7], b8 = b2[8], b9 = b2[9], b10 = b2[10], b11 = b2[11], b12 = b2[12], b13 = b2[13], b14 = b2[14], b15 = b2[15];
              v2 = a[0];
              t0 += v2 * b0;
              t1 += v2 * b1;
              t2 += v2 * b22;
              t3 += v2 * b3;
              t4 += v2 * b4;
              t5 += v2 * b5;
              t6 += v2 * b6;
              t7 += v2 * b7;
              t8 += v2 * b8;
              t9 += v2 * b9;
              t10 += v2 * b10;
              t11 += v2 * b11;
              t12 += v2 * b12;
              t13 += v2 * b13;
              t14 += v2 * b14;
              t15 += v2 * b15;
              v2 = a[1];
              t1 += v2 * b0;
              t2 += v2 * b1;
              t3 += v2 * b22;
              t4 += v2 * b3;
              t5 += v2 * b4;
              t6 += v2 * b5;
              t7 += v2 * b6;
              t8 += v2 * b7;
              t9 += v2 * b8;
              t10 += v2 * b9;
              t11 += v2 * b10;
              t12 += v2 * b11;
              t13 += v2 * b12;
              t14 += v2 * b13;
              t15 += v2 * b14;
              t16 += v2 * b15;
              v2 = a[2];
              t2 += v2 * b0;
              t3 += v2 * b1;
              t4 += v2 * b22;
              t5 += v2 * b3;
              t6 += v2 * b4;
              t7 += v2 * b5;
              t8 += v2 * b6;
              t9 += v2 * b7;
              t10 += v2 * b8;
              t11 += v2 * b9;
              t12 += v2 * b10;
              t13 += v2 * b11;
              t14 += v2 * b12;
              t15 += v2 * b13;
              t16 += v2 * b14;
              t17 += v2 * b15;
              v2 = a[3];
              t3 += v2 * b0;
              t4 += v2 * b1;
              t5 += v2 * b22;
              t6 += v2 * b3;
              t7 += v2 * b4;
              t8 += v2 * b5;
              t9 += v2 * b6;
              t10 += v2 * b7;
              t11 += v2 * b8;
              t12 += v2 * b9;
              t13 += v2 * b10;
              t14 += v2 * b11;
              t15 += v2 * b12;
              t16 += v2 * b13;
              t17 += v2 * b14;
              t18 += v2 * b15;
              v2 = a[4];
              t4 += v2 * b0;
              t5 += v2 * b1;
              t6 += v2 * b22;
              t7 += v2 * b3;
              t8 += v2 * b4;
              t9 += v2 * b5;
              t10 += v2 * b6;
              t11 += v2 * b7;
              t12 += v2 * b8;
              t13 += v2 * b9;
              t14 += v2 * b10;
              t15 += v2 * b11;
              t16 += v2 * b12;
              t17 += v2 * b13;
              t18 += v2 * b14;
              t19 += v2 * b15;
              v2 = a[5];
              t5 += v2 * b0;
              t6 += v2 * b1;
              t7 += v2 * b22;
              t8 += v2 * b3;
              t9 += v2 * b4;
              t10 += v2 * b5;
              t11 += v2 * b6;
              t12 += v2 * b7;
              t13 += v2 * b8;
              t14 += v2 * b9;
              t15 += v2 * b10;
              t16 += v2 * b11;
              t17 += v2 * b12;
              t18 += v2 * b13;
              t19 += v2 * b14;
              t20 += v2 * b15;
              v2 = a[6];
              t6 += v2 * b0;
              t7 += v2 * b1;
              t8 += v2 * b22;
              t9 += v2 * b3;
              t10 += v2 * b4;
              t11 += v2 * b5;
              t12 += v2 * b6;
              t13 += v2 * b7;
              t14 += v2 * b8;
              t15 += v2 * b9;
              t16 += v2 * b10;
              t17 += v2 * b11;
              t18 += v2 * b12;
              t19 += v2 * b13;
              t20 += v2 * b14;
              t21 += v2 * b15;
              v2 = a[7];
              t7 += v2 * b0;
              t8 += v2 * b1;
              t9 += v2 * b22;
              t10 += v2 * b3;
              t11 += v2 * b4;
              t12 += v2 * b5;
              t13 += v2 * b6;
              t14 += v2 * b7;
              t15 += v2 * b8;
              t16 += v2 * b9;
              t17 += v2 * b10;
              t18 += v2 * b11;
              t19 += v2 * b12;
              t20 += v2 * b13;
              t21 += v2 * b14;
              t22 += v2 * b15;
              v2 = a[8];
              t8 += v2 * b0;
              t9 += v2 * b1;
              t10 += v2 * b22;
              t11 += v2 * b3;
              t12 += v2 * b4;
              t13 += v2 * b5;
              t14 += v2 * b6;
              t15 += v2 * b7;
              t16 += v2 * b8;
              t17 += v2 * b9;
              t18 += v2 * b10;
              t19 += v2 * b11;
              t20 += v2 * b12;
              t21 += v2 * b13;
              t22 += v2 * b14;
              t23 += v2 * b15;
              v2 = a[9];
              t9 += v2 * b0;
              t10 += v2 * b1;
              t11 += v2 * b22;
              t12 += v2 * b3;
              t13 += v2 * b4;
              t14 += v2 * b5;
              t15 += v2 * b6;
              t16 += v2 * b7;
              t17 += v2 * b8;
              t18 += v2 * b9;
              t19 += v2 * b10;
              t20 += v2 * b11;
              t21 += v2 * b12;
              t22 += v2 * b13;
              t23 += v2 * b14;
              t24 += v2 * b15;
              v2 = a[10];
              t10 += v2 * b0;
              t11 += v2 * b1;
              t12 += v2 * b22;
              t13 += v2 * b3;
              t14 += v2 * b4;
              t15 += v2 * b5;
              t16 += v2 * b6;
              t17 += v2 * b7;
              t18 += v2 * b8;
              t19 += v2 * b9;
              t20 += v2 * b10;
              t21 += v2 * b11;
              t22 += v2 * b12;
              t23 += v2 * b13;
              t24 += v2 * b14;
              t25 += v2 * b15;
              v2 = a[11];
              t11 += v2 * b0;
              t12 += v2 * b1;
              t13 += v2 * b22;
              t14 += v2 * b3;
              t15 += v2 * b4;
              t16 += v2 * b5;
              t17 += v2 * b6;
              t18 += v2 * b7;
              t19 += v2 * b8;
              t20 += v2 * b9;
              t21 += v2 * b10;
              t22 += v2 * b11;
              t23 += v2 * b12;
              t24 += v2 * b13;
              t25 += v2 * b14;
              t26 += v2 * b15;
              v2 = a[12];
              t12 += v2 * b0;
              t13 += v2 * b1;
              t14 += v2 * b22;
              t15 += v2 * b3;
              t16 += v2 * b4;
              t17 += v2 * b5;
              t18 += v2 * b6;
              t19 += v2 * b7;
              t20 += v2 * b8;
              t21 += v2 * b9;
              t22 += v2 * b10;
              t23 += v2 * b11;
              t24 += v2 * b12;
              t25 += v2 * b13;
              t26 += v2 * b14;
              t27 += v2 * b15;
              v2 = a[13];
              t13 += v2 * b0;
              t14 += v2 * b1;
              t15 += v2 * b22;
              t16 += v2 * b3;
              t17 += v2 * b4;
              t18 += v2 * b5;
              t19 += v2 * b6;
              t20 += v2 * b7;
              t21 += v2 * b8;
              t22 += v2 * b9;
              t23 += v2 * b10;
              t24 += v2 * b11;
              t25 += v2 * b12;
              t26 += v2 * b13;
              t27 += v2 * b14;
              t28 += v2 * b15;
              v2 = a[14];
              t14 += v2 * b0;
              t15 += v2 * b1;
              t16 += v2 * b22;
              t17 += v2 * b3;
              t18 += v2 * b4;
              t19 += v2 * b5;
              t20 += v2 * b6;
              t21 += v2 * b7;
              t22 += v2 * b8;
              t23 += v2 * b9;
              t24 += v2 * b10;
              t25 += v2 * b11;
              t26 += v2 * b12;
              t27 += v2 * b13;
              t28 += v2 * b14;
              t29 += v2 * b15;
              v2 = a[15];
              t15 += v2 * b0;
              t16 += v2 * b1;
              t17 += v2 * b22;
              t18 += v2 * b3;
              t19 += v2 * b4;
              t20 += v2 * b5;
              t21 += v2 * b6;
              t22 += v2 * b7;
              t23 += v2 * b8;
              t24 += v2 * b9;
              t25 += v2 * b10;
              t26 += v2 * b11;
              t27 += v2 * b12;
              t28 += v2 * b13;
              t29 += v2 * b14;
              t30 += v2 * b15;
              t0 += 38 * t16;
              t1 += 38 * t17;
              t2 += 38 * t18;
              t3 += 38 * t19;
              t4 += 38 * t20;
              t5 += 38 * t21;
              t6 += 38 * t22;
              t7 += 38 * t23;
              t8 += 38 * t24;
              t9 += 38 * t25;
              t10 += 38 * t26;
              t11 += 38 * t27;
              t12 += 38 * t28;
              t13 += 38 * t29;
              t14 += 38 * t30;
              c2 = 1;
              v2 = t0 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t0 = v2 - c2 * 65536;
              v2 = t1 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t1 = v2 - c2 * 65536;
              v2 = t2 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t2 = v2 - c2 * 65536;
              v2 = t3 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t3 = v2 - c2 * 65536;
              v2 = t4 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t4 = v2 - c2 * 65536;
              v2 = t5 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t5 = v2 - c2 * 65536;
              v2 = t6 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t6 = v2 - c2 * 65536;
              v2 = t7 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t7 = v2 - c2 * 65536;
              v2 = t8 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t8 = v2 - c2 * 65536;
              v2 = t9 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t9 = v2 - c2 * 65536;
              v2 = t10 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t10 = v2 - c2 * 65536;
              v2 = t11 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t11 = v2 - c2 * 65536;
              v2 = t12 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t12 = v2 - c2 * 65536;
              v2 = t13 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t13 = v2 - c2 * 65536;
              v2 = t14 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t14 = v2 - c2 * 65536;
              v2 = t15 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t15 = v2 - c2 * 65536;
              t0 += c2 - 1 + 37 * (c2 - 1);
              c2 = 1;
              v2 = t0 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t0 = v2 - c2 * 65536;
              v2 = t1 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t1 = v2 - c2 * 65536;
              v2 = t2 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t2 = v2 - c2 * 65536;
              v2 = t3 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t3 = v2 - c2 * 65536;
              v2 = t4 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t4 = v2 - c2 * 65536;
              v2 = t5 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t5 = v2 - c2 * 65536;
              v2 = t6 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t6 = v2 - c2 * 65536;
              v2 = t7 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t7 = v2 - c2 * 65536;
              v2 = t8 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t8 = v2 - c2 * 65536;
              v2 = t9 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t9 = v2 - c2 * 65536;
              v2 = t10 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t10 = v2 - c2 * 65536;
              v2 = t11 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t11 = v2 - c2 * 65536;
              v2 = t12 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t12 = v2 - c2 * 65536;
              v2 = t13 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t13 = v2 - c2 * 65536;
              v2 = t14 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t14 = v2 - c2 * 65536;
              v2 = t15 + c2 + 65535;
              c2 = Math.floor(v2 / 65536);
              t15 = v2 - c2 * 65536;
              t0 += c2 - 1 + 37 * (c2 - 1);
              o2[0] = t0;
              o2[1] = t1;
              o2[2] = t2;
              o2[3] = t3;
              o2[4] = t4;
              o2[5] = t5;
              o2[6] = t6;
              o2[7] = t7;
              o2[8] = t8;
              o2[9] = t9;
              o2[10] = t10;
              o2[11] = t11;
              o2[12] = t12;
              o2[13] = t13;
              o2[14] = t14;
              o2[15] = t15;
            }
            function S2(o2, a) {
              M(o2, a, a);
            }
            function inv25519(o2, i) {
              var c2 = gf();
              var a;
              for (a = 0; a < 16; a++) c2[a] = i[a];
              for (a = 253; a >= 0; a--) {
                S2(c2, c2);
                if (a !== 2 && a !== 4) M(c2, c2, i);
              }
              for (a = 0; a < 16; a++) o2[a] = c2[a];
            }
            function pow2523(o2, i) {
              var c2 = gf();
              var a;
              for (a = 0; a < 16; a++) c2[a] = i[a];
              for (a = 250; a >= 0; a--) {
                S2(c2, c2);
                if (a !== 1) M(c2, c2, i);
              }
              for (a = 0; a < 16; a++) o2[a] = c2[a];
            }
            function crypto_scalarmult(q, n, p2) {
              var z = new Uint8Array(32);
              var x = new Float64Array(80), r2, i;
              var a = gf(), b2 = gf(), c2 = gf(), d2 = gf(), e = gf(), f2 = gf();
              for (i = 0; i < 31; i++) z[i] = n[i];
              z[31] = n[31] & 127 | 64;
              z[0] &= 248;
              unpack25519(x, p2);
              for (i = 0; i < 16; i++) {
                b2[i] = x[i];
                d2[i] = a[i] = c2[i] = 0;
              }
              a[0] = d2[0] = 1;
              for (i = 254; i >= 0; --i) {
                r2 = z[i >>> 3] >>> (i & 7) & 1;
                sel25519(a, b2, r2);
                sel25519(c2, d2, r2);
                A(e, a, c2);
                Z(a, a, c2);
                A(c2, b2, d2);
                Z(b2, b2, d2);
                S2(d2, e);
                S2(f2, a);
                M(a, c2, a);
                M(c2, b2, e);
                A(e, a, c2);
                Z(a, a, c2);
                S2(b2, a);
                Z(c2, d2, f2);
                M(a, c2, _121665);
                A(a, a, d2);
                M(c2, c2, a);
                M(a, d2, f2);
                M(d2, b2, x);
                S2(b2, e);
                sel25519(a, b2, r2);
                sel25519(c2, d2, r2);
              }
              for (i = 0; i < 16; i++) {
                x[i + 16] = a[i];
                x[i + 32] = c2[i];
                x[i + 48] = b2[i];
                x[i + 64] = d2[i];
              }
              var x32 = x.subarray(32);
              var x16 = x.subarray(16);
              inv25519(x32, x32);
              M(x16, x16, x32);
              pack25519(q, x16);
              return 0;
            }
            function crypto_scalarmult_base(q, n) {
              return crypto_scalarmult(q, n, _9);
            }
            function crypto_box_keypair(y2, x) {
              randombytes(x, 32);
              return crypto_scalarmult_base(y2, x);
            }
            function crypto_box_beforenm(k2, y2, x) {
              var s = new Uint8Array(32);
              crypto_scalarmult(s, x, y2);
              return crypto_core_hsalsa20(k2, _0, s, sigma);
            }
            var crypto_box_afternm = crypto_secretbox;
            var crypto_box_open_afternm = crypto_secretbox_open;
            function crypto_box(c2, m2, d2, n, y2, x) {
              var k2 = new Uint8Array(32);
              crypto_box_beforenm(k2, y2, x);
              return crypto_box_afternm(c2, m2, d2, n, k2);
            }
            function crypto_box_open(m2, c2, d2, n, y2, x) {
              var k2 = new Uint8Array(32);
              crypto_box_beforenm(k2, y2, x);
              return crypto_box_open_afternm(m2, c2, d2, n, k2);
            }
            var K = [
              1116352408,
              3609767458,
              1899447441,
              602891725,
              3049323471,
              3964484399,
              3921009573,
              2173295548,
              961987163,
              4081628472,
              1508970993,
              3053834265,
              2453635748,
              2937671579,
              2870763221,
              3664609560,
              3624381080,
              2734883394,
              310598401,
              1164996542,
              607225278,
              1323610764,
              1426881987,
              3590304994,
              1925078388,
              4068182383,
              2162078206,
              991336113,
              2614888103,
              633803317,
              3248222580,
              3479774868,
              3835390401,
              2666613458,
              4022224774,
              944711139,
              264347078,
              2341262773,
              604807628,
              2007800933,
              770255983,
              1495990901,
              1249150122,
              1856431235,
              1555081692,
              3175218132,
              1996064986,
              2198950837,
              2554220882,
              3999719339,
              2821834349,
              766784016,
              2952996808,
              2566594879,
              3210313671,
              3203337956,
              3336571891,
              1034457026,
              3584528711,
              2466948901,
              113926993,
              3758326383,
              338241895,
              168717936,
              666307205,
              1188179964,
              773529912,
              1546045734,
              1294757372,
              1522805485,
              1396182291,
              2643833823,
              1695183700,
              2343527390,
              1986661051,
              1014477480,
              2177026350,
              1206759142,
              2456956037,
              344077627,
              2730485921,
              1290863460,
              2820302411,
              3158454273,
              3259730800,
              3505952657,
              3345764771,
              106217008,
              3516065817,
              3606008344,
              3600352804,
              1432725776,
              4094571909,
              1467031594,
              275423344,
              851169720,
              430227734,
              3100823752,
              506948616,
              1363258195,
              659060556,
              3750685593,
              883997877,
              3785050280,
              958139571,
              3318307427,
              1322822218,
              3812723403,
              1537002063,
              2003034995,
              1747873779,
              3602036899,
              1955562222,
              1575990012,
              2024104815,
              1125592928,
              2227730452,
              2716904306,
              2361852424,
              442776044,
              2428436474,
              593698344,
              2756734187,
              3733110249,
              3204031479,
              2999351573,
              3329325298,
              3815920427,
              3391569614,
              3928383900,
              3515267271,
              566280711,
              3940187606,
              3454069534,
              4118630271,
              4000239992,
              116418474,
              1914138554,
              174292421,
              2731055270,
              289380356,
              3203993006,
              460393269,
              320620315,
              685471733,
              587496836,
              852142971,
              1086792851,
              1017036298,
              365543100,
              1126000580,
              2618297676,
              1288033470,
              3409855158,
              1501505948,
              4234509866,
              1607167915,
              987167468,
              1816402316,
              1246189591
            ];
            function crypto_hashblocks_hl(hh, hl, m2, n) {
              var wh = new Int32Array(16), wl = new Int32Array(16), bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7, bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7, th, tl, i, j, h3, l2, a, b2, c2, d2;
              var ah0 = hh[0], ah1 = hh[1], ah2 = hh[2], ah3 = hh[3], ah4 = hh[4], ah5 = hh[5], ah6 = hh[6], ah7 = hh[7], al0 = hl[0], al1 = hl[1], al2 = hl[2], al3 = hl[3], al4 = hl[4], al5 = hl[5], al6 = hl[6], al7 = hl[7];
              var pos = 0;
              while (n >= 128) {
                for (i = 0; i < 16; i++) {
                  j = 8 * i + pos;
                  wh[i] = m2[j + 0] << 24 | m2[j + 1] << 16 | m2[j + 2] << 8 | m2[j + 3];
                  wl[i] = m2[j + 4] << 24 | m2[j + 5] << 16 | m2[j + 6] << 8 | m2[j + 7];
                }
                for (i = 0; i < 80; i++) {
                  bh0 = ah0;
                  bh1 = ah1;
                  bh2 = ah2;
                  bh3 = ah3;
                  bh4 = ah4;
                  bh5 = ah5;
                  bh6 = ah6;
                  bh7 = ah7;
                  bl0 = al0;
                  bl1 = al1;
                  bl2 = al2;
                  bl3 = al3;
                  bl4 = al4;
                  bl5 = al5;
                  bl6 = al6;
                  bl7 = al7;
                  h3 = ah7;
                  l2 = al7;
                  a = l2 & 65535;
                  b2 = l2 >>> 16;
                  c2 = h3 & 65535;
                  d2 = h3 >>> 16;
                  h3 = (ah4 >>> 14 | al4 << 32 - 14) ^ (ah4 >>> 18 | al4 << 32 - 18) ^ (al4 >>> 41 - 32 | ah4 << 32 - (41 - 32));
                  l2 = (al4 >>> 14 | ah4 << 32 - 14) ^ (al4 >>> 18 | ah4 << 32 - 18) ^ (ah4 >>> 41 - 32 | al4 << 32 - (41 - 32));
                  a += l2 & 65535;
                  b2 += l2 >>> 16;
                  c2 += h3 & 65535;
                  d2 += h3 >>> 16;
                  h3 = ah4 & ah5 ^ ~ah4 & ah6;
                  l2 = al4 & al5 ^ ~al4 & al6;
                  a += l2 & 65535;
                  b2 += l2 >>> 16;
                  c2 += h3 & 65535;
                  d2 += h3 >>> 16;
                  h3 = K[i * 2];
                  l2 = K[i * 2 + 1];
                  a += l2 & 65535;
                  b2 += l2 >>> 16;
                  c2 += h3 & 65535;
                  d2 += h3 >>> 16;
                  h3 = wh[i % 16];
                  l2 = wl[i % 16];
                  a += l2 & 65535;
                  b2 += l2 >>> 16;
                  c2 += h3 & 65535;
                  d2 += h3 >>> 16;
                  b2 += a >>> 16;
                  c2 += b2 >>> 16;
                  d2 += c2 >>> 16;
                  th = c2 & 65535 | d2 << 16;
                  tl = a & 65535 | b2 << 16;
                  h3 = th;
                  l2 = tl;
                  a = l2 & 65535;
                  b2 = l2 >>> 16;
                  c2 = h3 & 65535;
                  d2 = h3 >>> 16;
                  h3 = (ah0 >>> 28 | al0 << 32 - 28) ^ (al0 >>> 34 - 32 | ah0 << 32 - (34 - 32)) ^ (al0 >>> 39 - 32 | ah0 << 32 - (39 - 32));
                  l2 = (al0 >>> 28 | ah0 << 32 - 28) ^ (ah0 >>> 34 - 32 | al0 << 32 - (34 - 32)) ^ (ah0 >>> 39 - 32 | al0 << 32 - (39 - 32));
                  a += l2 & 65535;
                  b2 += l2 >>> 16;
                  c2 += h3 & 65535;
                  d2 += h3 >>> 16;
                  h3 = ah0 & ah1 ^ ah0 & ah2 ^ ah1 & ah2;
                  l2 = al0 & al1 ^ al0 & al2 ^ al1 & al2;
                  a += l2 & 65535;
                  b2 += l2 >>> 16;
                  c2 += h3 & 65535;
                  d2 += h3 >>> 16;
                  b2 += a >>> 16;
                  c2 += b2 >>> 16;
                  d2 += c2 >>> 16;
                  bh7 = c2 & 65535 | d2 << 16;
                  bl7 = a & 65535 | b2 << 16;
                  h3 = bh3;
                  l2 = bl3;
                  a = l2 & 65535;
                  b2 = l2 >>> 16;
                  c2 = h3 & 65535;
                  d2 = h3 >>> 16;
                  h3 = th;
                  l2 = tl;
                  a += l2 & 65535;
                  b2 += l2 >>> 16;
                  c2 += h3 & 65535;
                  d2 += h3 >>> 16;
                  b2 += a >>> 16;
                  c2 += b2 >>> 16;
                  d2 += c2 >>> 16;
                  bh3 = c2 & 65535 | d2 << 16;
                  bl3 = a & 65535 | b2 << 16;
                  ah1 = bh0;
                  ah2 = bh1;
                  ah3 = bh2;
                  ah4 = bh3;
                  ah5 = bh4;
                  ah6 = bh5;
                  ah7 = bh6;
                  ah0 = bh7;
                  al1 = bl0;
                  al2 = bl1;
                  al3 = bl2;
                  al4 = bl3;
                  al5 = bl4;
                  al6 = bl5;
                  al7 = bl6;
                  al0 = bl7;
                  if (i % 16 === 15) {
                    for (j = 0; j < 16; j++) {
                      h3 = wh[j];
                      l2 = wl[j];
                      a = l2 & 65535;
                      b2 = l2 >>> 16;
                      c2 = h3 & 65535;
                      d2 = h3 >>> 16;
                      h3 = wh[(j + 9) % 16];
                      l2 = wl[(j + 9) % 16];
                      a += l2 & 65535;
                      b2 += l2 >>> 16;
                      c2 += h3 & 65535;
                      d2 += h3 >>> 16;
                      th = wh[(j + 1) % 16];
                      tl = wl[(j + 1) % 16];
                      h3 = (th >>> 1 | tl << 32 - 1) ^ (th >>> 8 | tl << 32 - 8) ^ th >>> 7;
                      l2 = (tl >>> 1 | th << 32 - 1) ^ (tl >>> 8 | th << 32 - 8) ^ (tl >>> 7 | th << 32 - 7);
                      a += l2 & 65535;
                      b2 += l2 >>> 16;
                      c2 += h3 & 65535;
                      d2 += h3 >>> 16;
                      th = wh[(j + 14) % 16];
                      tl = wl[(j + 14) % 16];
                      h3 = (th >>> 19 | tl << 32 - 19) ^ (tl >>> 61 - 32 | th << 32 - (61 - 32)) ^ th >>> 6;
                      l2 = (tl >>> 19 | th << 32 - 19) ^ (th >>> 61 - 32 | tl << 32 - (61 - 32)) ^ (tl >>> 6 | th << 32 - 6);
                      a += l2 & 65535;
                      b2 += l2 >>> 16;
                      c2 += h3 & 65535;
                      d2 += h3 >>> 16;
                      b2 += a >>> 16;
                      c2 += b2 >>> 16;
                      d2 += c2 >>> 16;
                      wh[j] = c2 & 65535 | d2 << 16;
                      wl[j] = a & 65535 | b2 << 16;
                    }
                  }
                }
                h3 = ah0;
                l2 = al0;
                a = l2 & 65535;
                b2 = l2 >>> 16;
                c2 = h3 & 65535;
                d2 = h3 >>> 16;
                h3 = hh[0];
                l2 = hl[0];
                a += l2 & 65535;
                b2 += l2 >>> 16;
                c2 += h3 & 65535;
                d2 += h3 >>> 16;
                b2 += a >>> 16;
                c2 += b2 >>> 16;
                d2 += c2 >>> 16;
                hh[0] = ah0 = c2 & 65535 | d2 << 16;
                hl[0] = al0 = a & 65535 | b2 << 16;
                h3 = ah1;
                l2 = al1;
                a = l2 & 65535;
                b2 = l2 >>> 16;
                c2 = h3 & 65535;
                d2 = h3 >>> 16;
                h3 = hh[1];
                l2 = hl[1];
                a += l2 & 65535;
                b2 += l2 >>> 16;
                c2 += h3 & 65535;
                d2 += h3 >>> 16;
                b2 += a >>> 16;
                c2 += b2 >>> 16;
                d2 += c2 >>> 16;
                hh[1] = ah1 = c2 & 65535 | d2 << 16;
                hl[1] = al1 = a & 65535 | b2 << 16;
                h3 = ah2;
                l2 = al2;
                a = l2 & 65535;
                b2 = l2 >>> 16;
                c2 = h3 & 65535;
                d2 = h3 >>> 16;
                h3 = hh[2];
                l2 = hl[2];
                a += l2 & 65535;
                b2 += l2 >>> 16;
                c2 += h3 & 65535;
                d2 += h3 >>> 16;
                b2 += a >>> 16;
                c2 += b2 >>> 16;
                d2 += c2 >>> 16;
                hh[2] = ah2 = c2 & 65535 | d2 << 16;
                hl[2] = al2 = a & 65535 | b2 << 16;
                h3 = ah3;
                l2 = al3;
                a = l2 & 65535;
                b2 = l2 >>> 16;
                c2 = h3 & 65535;
                d2 = h3 >>> 16;
                h3 = hh[3];
                l2 = hl[3];
                a += l2 & 65535;
                b2 += l2 >>> 16;
                c2 += h3 & 65535;
                d2 += h3 >>> 16;
                b2 += a >>> 16;
                c2 += b2 >>> 16;
                d2 += c2 >>> 16;
                hh[3] = ah3 = c2 & 65535 | d2 << 16;
                hl[3] = al3 = a & 65535 | b2 << 16;
                h3 = ah4;
                l2 = al4;
                a = l2 & 65535;
                b2 = l2 >>> 16;
                c2 = h3 & 65535;
                d2 = h3 >>> 16;
                h3 = hh[4];
                l2 = hl[4];
                a += l2 & 65535;
                b2 += l2 >>> 16;
                c2 += h3 & 65535;
                d2 += h3 >>> 16;
                b2 += a >>> 16;
                c2 += b2 >>> 16;
                d2 += c2 >>> 16;
                hh[4] = ah4 = c2 & 65535 | d2 << 16;
                hl[4] = al4 = a & 65535 | b2 << 16;
                h3 = ah5;
                l2 = al5;
                a = l2 & 65535;
                b2 = l2 >>> 16;
                c2 = h3 & 65535;
                d2 = h3 >>> 16;
                h3 = hh[5];
                l2 = hl[5];
                a += l2 & 65535;
                b2 += l2 >>> 16;
                c2 += h3 & 65535;
                d2 += h3 >>> 16;
                b2 += a >>> 16;
                c2 += b2 >>> 16;
                d2 += c2 >>> 16;
                hh[5] = ah5 = c2 & 65535 | d2 << 16;
                hl[5] = al5 = a & 65535 | b2 << 16;
                h3 = ah6;
                l2 = al6;
                a = l2 & 65535;
                b2 = l2 >>> 16;
                c2 = h3 & 65535;
                d2 = h3 >>> 16;
                h3 = hh[6];
                l2 = hl[6];
                a += l2 & 65535;
                b2 += l2 >>> 16;
                c2 += h3 & 65535;
                d2 += h3 >>> 16;
                b2 += a >>> 16;
                c2 += b2 >>> 16;
                d2 += c2 >>> 16;
                hh[6] = ah6 = c2 & 65535 | d2 << 16;
                hl[6] = al6 = a & 65535 | b2 << 16;
                h3 = ah7;
                l2 = al7;
                a = l2 & 65535;
                b2 = l2 >>> 16;
                c2 = h3 & 65535;
                d2 = h3 >>> 16;
                h3 = hh[7];
                l2 = hl[7];
                a += l2 & 65535;
                b2 += l2 >>> 16;
                c2 += h3 & 65535;
                d2 += h3 >>> 16;
                b2 += a >>> 16;
                c2 += b2 >>> 16;
                d2 += c2 >>> 16;
                hh[7] = ah7 = c2 & 65535 | d2 << 16;
                hl[7] = al7 = a & 65535 | b2 << 16;
                pos += 128;
                n -= 128;
              }
              return n;
            }
            function crypto_hash(out, m2, n) {
              var hh = new Int32Array(8), hl = new Int32Array(8), x = new Uint8Array(256), i, b2 = n;
              hh[0] = 1779033703;
              hh[1] = 3144134277;
              hh[2] = 1013904242;
              hh[3] = 2773480762;
              hh[4] = 1359893119;
              hh[5] = 2600822924;
              hh[6] = 528734635;
              hh[7] = 1541459225;
              hl[0] = 4089235720;
              hl[1] = 2227873595;
              hl[2] = 4271175723;
              hl[3] = 1595750129;
              hl[4] = 2917565137;
              hl[5] = 725511199;
              hl[6] = 4215389547;
              hl[7] = 327033209;
              crypto_hashblocks_hl(hh, hl, m2, n);
              n %= 128;
              for (i = 0; i < n; i++) x[i] = m2[b2 - n + i];
              x[n] = 128;
              n = 256 - 128 * (n < 112 ? 1 : 0);
              x[n - 9] = 0;
              ts64(x, n - 8, b2 / 536870912 | 0, b2 << 3);
              crypto_hashblocks_hl(hh, hl, x, n);
              for (i = 0; i < 8; i++) ts64(out, 8 * i, hh[i], hl[i]);
              return 0;
            }
            function add(p2, q) {
              var a = gf(), b2 = gf(), c2 = gf(), d2 = gf(), e = gf(), f2 = gf(), g2 = gf(), h3 = gf(), t = gf();
              Z(a, p2[1], p2[0]);
              Z(t, q[1], q[0]);
              M(a, a, t);
              A(b2, p2[0], p2[1]);
              A(t, q[0], q[1]);
              M(b2, b2, t);
              M(c2, p2[3], q[3]);
              M(c2, c2, D2);
              M(d2, p2[2], q[2]);
              A(d2, d2, d2);
              Z(e, b2, a);
              Z(f2, d2, c2);
              A(g2, d2, c2);
              A(h3, b2, a);
              M(p2[0], e, f2);
              M(p2[1], h3, g2);
              M(p2[2], g2, f2);
              M(p2[3], e, h3);
            }
            function cswap(p2, q, b2) {
              var i;
              for (i = 0; i < 4; i++) {
                sel25519(p2[i], q[i], b2);
              }
            }
            function pack(r2, p2) {
              var tx = gf(), ty = gf(), zi = gf();
              inv25519(zi, p2[2]);
              M(tx, p2[0], zi);
              M(ty, p2[1], zi);
              pack25519(r2, ty);
              r2[31] ^= par25519(tx) << 7;
            }
            function scalarmult(p2, q, s) {
              var b2, i;
              set25519(p2[0], gf0);
              set25519(p2[1], gf1);
              set25519(p2[2], gf1);
              set25519(p2[3], gf0);
              for (i = 255; i >= 0; --i) {
                b2 = s[i / 8 | 0] >> (i & 7) & 1;
                cswap(p2, q, b2);
                add(q, p2);
                add(p2, p2);
                cswap(p2, q, b2);
              }
            }
            function scalarbase(p2, s) {
              var q = [gf(), gf(), gf(), gf()];
              set25519(q[0], X);
              set25519(q[1], Y);
              set25519(q[2], gf1);
              M(q[3], X, Y);
              scalarmult(p2, q, s);
            }
            function crypto_sign_keypair(pk, sk, seeded) {
              var d2 = new Uint8Array(64);
              var p2 = [gf(), gf(), gf(), gf()];
              var i;
              if (!seeded) randombytes(sk, 32);
              crypto_hash(d2, sk, 32);
              d2[0] &= 248;
              d2[31] &= 127;
              d2[31] |= 64;
              scalarbase(p2, d2);
              pack(pk, p2);
              for (i = 0; i < 32; i++) sk[i + 32] = pk[i];
              return 0;
            }
            var L = new Float64Array([237, 211, 245, 92, 26, 99, 18, 88, 214, 156, 247, 162, 222, 249, 222, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16]);
            function modL(r2, x) {
              var carry, i, j, k2;
              for (i = 63; i >= 32; --i) {
                carry = 0;
                for (j = i - 32, k2 = i - 12; j < k2; ++j) {
                  x[j] += carry - 16 * x[i] * L[j - (i - 32)];
                  carry = Math.floor((x[j] + 128) / 256);
                  x[j] -= carry * 256;
                }
                x[j] += carry;
                x[i] = 0;
              }
              carry = 0;
              for (j = 0; j < 32; j++) {
                x[j] += carry - (x[31] >> 4) * L[j];
                carry = x[j] >> 8;
                x[j] &= 255;
              }
              for (j = 0; j < 32; j++) x[j] -= carry * L[j];
              for (i = 0; i < 32; i++) {
                x[i + 1] += x[i] >> 8;
                r2[i] = x[i] & 255;
              }
            }
            function reduce(r2) {
              var x = new Float64Array(64), i;
              for (i = 0; i < 64; i++) x[i] = r2[i];
              for (i = 0; i < 64; i++) r2[i] = 0;
              modL(r2, x);
            }
            function crypto_sign(sm, m2, n, sk) {
              var d2 = new Uint8Array(64), h3 = new Uint8Array(64), r2 = new Uint8Array(64);
              var i, j, x = new Float64Array(64);
              var p2 = [gf(), gf(), gf(), gf()];
              crypto_hash(d2, sk, 32);
              d2[0] &= 248;
              d2[31] &= 127;
              d2[31] |= 64;
              var smlen = n + 64;
              for (i = 0; i < n; i++) sm[64 + i] = m2[i];
              for (i = 0; i < 32; i++) sm[32 + i] = d2[32 + i];
              crypto_hash(r2, sm.subarray(32), n + 32);
              reduce(r2);
              scalarbase(p2, r2);
              pack(sm, p2);
              for (i = 32; i < 64; i++) sm[i] = sk[i];
              crypto_hash(h3, sm, n + 64);
              reduce(h3);
              for (i = 0; i < 64; i++) x[i] = 0;
              for (i = 0; i < 32; i++) x[i] = r2[i];
              for (i = 0; i < 32; i++) {
                for (j = 0; j < 32; j++) {
                  x[i + j] += h3[i] * d2[j];
                }
              }
              modL(sm.subarray(32), x);
              return smlen;
            }
            function unpackneg(r2, p2) {
              var t = gf(), chk = gf(), num = gf(), den = gf(), den2 = gf(), den4 = gf(), den6 = gf();
              set25519(r2[2], gf1);
              unpack25519(r2[1], p2);
              S2(num, r2[1]);
              M(den, num, D);
              Z(num, num, r2[2]);
              A(den, r2[2], den);
              S2(den2, den);
              S2(den4, den2);
              M(den6, den4, den2);
              M(t, den6, num);
              M(t, t, den);
              pow2523(t, t);
              M(t, t, num);
              M(t, t, den);
              M(t, t, den);
              M(r2[0], t, den);
              S2(chk, r2[0]);
              M(chk, chk, den);
              if (neq25519(chk, num)) M(r2[0], r2[0], I);
              S2(chk, r2[0]);
              M(chk, chk, den);
              if (neq25519(chk, num)) return -1;
              if (par25519(r2[0]) === p2[31] >> 7) Z(r2[0], gf0, r2[0]);
              M(r2[3], r2[0], r2[1]);
              return 0;
            }
            function crypto_sign_open(m2, sm, n, pk) {
              var i;
              var t = new Uint8Array(32), h3 = new Uint8Array(64);
              var p2 = [gf(), gf(), gf(), gf()], q = [gf(), gf(), gf(), gf()];
              if (n < 64) return -1;
              if (unpackneg(q, pk)) return -1;
              for (i = 0; i < n; i++) m2[i] = sm[i];
              for (i = 0; i < 32; i++) m2[i + 32] = pk[i];
              crypto_hash(h3, m2, n);
              reduce(h3);
              scalarmult(p2, q, h3);
              scalarbase(q, sm.subarray(32));
              add(p2, q);
              pack(t, p2);
              n -= 64;
              if (crypto_verify_32(sm, 0, t, 0)) {
                for (i = 0; i < n; i++) m2[i] = 0;
                return -1;
              }
              for (i = 0; i < n; i++) m2[i] = sm[i + 64];
              return n;
            }
            var crypto_secretbox_KEYBYTES = 32, crypto_secretbox_NONCEBYTES = 24, crypto_secretbox_ZEROBYTES = 32, crypto_secretbox_BOXZEROBYTES = 16, crypto_scalarmult_BYTES = 32, crypto_scalarmult_SCALARBYTES = 32, crypto_box_PUBLICKEYBYTES = 32, crypto_box_SECRETKEYBYTES = 32, crypto_box_BEFORENMBYTES = 32, crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES, crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES, crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES, crypto_sign_BYTES = 64, crypto_sign_PUBLICKEYBYTES = 32, crypto_sign_SECRETKEYBYTES = 64, crypto_sign_SEEDBYTES = 32, crypto_hash_BYTES = 64;
            nacl.lowlevel = {
              crypto_core_hsalsa20,
              crypto_stream_xor,
              crypto_stream,
              crypto_stream_salsa20_xor,
              crypto_stream_salsa20,
              crypto_onetimeauth,
              crypto_onetimeauth_verify,
              crypto_verify_16,
              crypto_verify_32,
              crypto_secretbox,
              crypto_secretbox_open,
              crypto_scalarmult,
              crypto_scalarmult_base,
              crypto_box_beforenm,
              crypto_box_afternm,
              crypto_box,
              crypto_box_open,
              crypto_box_keypair,
              crypto_hash,
              crypto_sign,
              crypto_sign_keypair,
              crypto_sign_open,
              crypto_secretbox_KEYBYTES,
              crypto_secretbox_NONCEBYTES,
              crypto_secretbox_ZEROBYTES,
              crypto_secretbox_BOXZEROBYTES,
              crypto_scalarmult_BYTES,
              crypto_scalarmult_SCALARBYTES,
              crypto_box_PUBLICKEYBYTES,
              crypto_box_SECRETKEYBYTES,
              crypto_box_BEFORENMBYTES,
              crypto_box_NONCEBYTES,
              crypto_box_ZEROBYTES,
              crypto_box_BOXZEROBYTES,
              crypto_sign_BYTES,
              crypto_sign_PUBLICKEYBYTES,
              crypto_sign_SECRETKEYBYTES,
              crypto_sign_SEEDBYTES,
              crypto_hash_BYTES,
              gf,
              D,
              L,
              pack25519,
              unpack25519,
              M,
              A,
              S: S2,
              Z,
              pow2523,
              add,
              set25519,
              modL,
              scalarmult,
              scalarbase
            };
            function checkLengths(k2, n) {
              if (k2.length !== crypto_secretbox_KEYBYTES) throw new Error("bad key size");
              if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error("bad nonce size");
            }
            function checkBoxLengths(pk, sk) {
              if (pk.length !== crypto_box_PUBLICKEYBYTES) throw new Error("bad public key size");
              if (sk.length !== crypto_box_SECRETKEYBYTES) throw new Error("bad secret key size");
            }
            function checkArrayTypes() {
              for (var i = 0; i < arguments.length; i++) {
                if (!(arguments[i] instanceof Uint8Array))
                  throw new TypeError("unexpected type, use Uint8Array");
              }
            }
            function cleanup(arr) {
              for (var i = 0; i < arr.length; i++) arr[i] = 0;
            }
            nacl.randomBytes = function(n) {
              var b2 = new Uint8Array(n);
              randombytes(b2, n);
              return b2;
            };
            nacl.secretbox = function(msg, nonce, key) {
              checkArrayTypes(msg, nonce, key);
              checkLengths(key, nonce);
              var m2 = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
              var c2 = new Uint8Array(m2.length);
              for (var i = 0; i < msg.length; i++) m2[i + crypto_secretbox_ZEROBYTES] = msg[i];
              crypto_secretbox(c2, m2, m2.length, nonce, key);
              return c2.subarray(crypto_secretbox_BOXZEROBYTES);
            };
            nacl.secretbox.open = function(box, nonce, key) {
              checkArrayTypes(box, nonce, key);
              checkLengths(key, nonce);
              var c2 = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
              var m2 = new Uint8Array(c2.length);
              for (var i = 0; i < box.length; i++) c2[i + crypto_secretbox_BOXZEROBYTES] = box[i];
              if (c2.length < 32) return null;
              if (crypto_secretbox_open(m2, c2, c2.length, nonce, key) !== 0) return null;
              return m2.subarray(crypto_secretbox_ZEROBYTES);
            };
            nacl.secretbox.keyLength = crypto_secretbox_KEYBYTES;
            nacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES;
            nacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES;
            nacl.scalarMult = function(n, p2) {
              checkArrayTypes(n, p2);
              if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error("bad n size");
              if (p2.length !== crypto_scalarmult_BYTES) throw new Error("bad p size");
              var q = new Uint8Array(crypto_scalarmult_BYTES);
              crypto_scalarmult(q, n, p2);
              return q;
            };
            nacl.scalarMult.base = function(n) {
              checkArrayTypes(n);
              if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error("bad n size");
              var q = new Uint8Array(crypto_scalarmult_BYTES);
              crypto_scalarmult_base(q, n);
              return q;
            };
            nacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES;
            nacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES;
            nacl.box = function(msg, nonce, publicKey, secretKey) {
              var k2 = nacl.box.before(publicKey, secretKey);
              return nacl.secretbox(msg, nonce, k2);
            };
            nacl.box.before = function(publicKey, secretKey) {
              checkArrayTypes(publicKey, secretKey);
              checkBoxLengths(publicKey, secretKey);
              var k2 = new Uint8Array(crypto_box_BEFORENMBYTES);
              crypto_box_beforenm(k2, publicKey, secretKey);
              return k2;
            };
            nacl.box.after = nacl.secretbox;
            nacl.box.open = function(msg, nonce, publicKey, secretKey) {
              var k2 = nacl.box.before(publicKey, secretKey);
              return nacl.secretbox.open(msg, nonce, k2);
            };
            nacl.box.open.after = nacl.secretbox.open;
            nacl.box.keyPair = function() {
              var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
              var sk = new Uint8Array(crypto_box_SECRETKEYBYTES);
              crypto_box_keypair(pk, sk);
              return { publicKey: pk, secretKey: sk };
            };
            nacl.box.keyPair.fromSecretKey = function(secretKey) {
              checkArrayTypes(secretKey);
              if (secretKey.length !== crypto_box_SECRETKEYBYTES)
                throw new Error("bad secret key size");
              var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
              crypto_scalarmult_base(pk, secretKey);
              return { publicKey: pk, secretKey: new Uint8Array(secretKey) };
            };
            nacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES;
            nacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES;
            nacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES;
            nacl.box.nonceLength = crypto_box_NONCEBYTES;
            nacl.box.overheadLength = nacl.secretbox.overheadLength;
            nacl.sign = function(msg, secretKey) {
              checkArrayTypes(msg, secretKey);
              if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
                throw new Error("bad secret key size");
              var signedMsg = new Uint8Array(crypto_sign_BYTES + msg.length);
              crypto_sign(signedMsg, msg, msg.length, secretKey);
              return signedMsg;
            };
            nacl.sign.open = function(signedMsg, publicKey) {
              checkArrayTypes(signedMsg, publicKey);
              if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
                throw new Error("bad public key size");
              var tmp = new Uint8Array(signedMsg.length);
              var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey);
              if (mlen < 0) return null;
              var m2 = new Uint8Array(mlen);
              for (var i = 0; i < m2.length; i++) m2[i] = tmp[i];
              return m2;
            };
            nacl.sign.detached = function(msg, secretKey) {
              var signedMsg = nacl.sign(msg, secretKey);
              var sig = new Uint8Array(crypto_sign_BYTES);
              for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i];
              return sig;
            };
            nacl.sign.detached.verify = function(msg, sig, publicKey) {
              checkArrayTypes(msg, sig, publicKey);
              if (sig.length !== crypto_sign_BYTES)
                throw new Error("bad signature size");
              if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
                throw new Error("bad public key size");
              var sm = new Uint8Array(crypto_sign_BYTES + msg.length);
              var m2 = new Uint8Array(crypto_sign_BYTES + msg.length);
              var i;
              for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i];
              for (i = 0; i < msg.length; i++) sm[i + crypto_sign_BYTES] = msg[i];
              return crypto_sign_open(m2, sm, sm.length, publicKey) >= 0;
            };
            nacl.sign.keyPair = function() {
              var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
              var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
              crypto_sign_keypair(pk, sk);
              return { publicKey: pk, secretKey: sk };
            };
            nacl.sign.keyPair.fromSecretKey = function(secretKey) {
              checkArrayTypes(secretKey);
              if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
                throw new Error("bad secret key size");
              var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
              for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32 + i];
              return { publicKey: pk, secretKey: new Uint8Array(secretKey) };
            };
            nacl.sign.keyPair.fromSeed = function(seed) {
              checkArrayTypes(seed);
              if (seed.length !== crypto_sign_SEEDBYTES)
                throw new Error("bad seed size");
              var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
              var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
              for (var i = 0; i < 32; i++) sk[i] = seed[i];
              crypto_sign_keypair(pk, sk, true);
              return { publicKey: pk, secretKey: sk };
            };
            nacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES;
            nacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES;
            nacl.sign.seedLength = crypto_sign_SEEDBYTES;
            nacl.sign.signatureLength = crypto_sign_BYTES;
            nacl.hash = function(msg) {
              checkArrayTypes(msg);
              var h3 = new Uint8Array(crypto_hash_BYTES);
              crypto_hash(h3, msg, msg.length);
              return h3;
            };
            nacl.hash.hashLength = crypto_hash_BYTES;
            nacl.verify = function(x, y2) {
              checkArrayTypes(x, y2);
              if (x.length === 0 || y2.length === 0) return false;
              if (x.length !== y2.length) return false;
              return vn(x, 0, y2, 0, x.length) === 0 ? true : false;
            };
            nacl.setPRNG = function(fn) {
              randombytes = fn;
            };
            (function() {
              var crypto = typeof self !== "undefined" ? self.crypto || self.msCrypto : null;
              if (crypto && crypto.getRandomValues) {
                var QUOTA = 65536;
                nacl.setPRNG(function(x, n) {
                  var i, v2 = new Uint8Array(n);
                  for (i = 0; i < n; i += QUOTA) {
                    crypto.getRandomValues(v2.subarray(i, i + Math.min(n - i, QUOTA)));
                  }
                  for (i = 0; i < n; i++) x[i] = v2[i];
                  cleanup(v2);
                });
              } else {
                crypto = __webpack_require__2(982);
                if (crypto && crypto.randomBytes) {
                  nacl.setPRNG(function(x, n) {
                    var i, v2 = crypto.randomBytes(n);
                    for (i = 0; i < n; i++) x[i] = v2[i];
                    cleanup(v2);
                  });
                }
              }
            })();
          })(module2.exports ? module2.exports : self.nacl = self.nacl || {});
        },
        /***/
        41(module2, __unused_webpack_exports, __webpack_require__2) {
          var Base = __webpack_require__2(369), Client = __webpack_require__2(483), Server = __webpack_require__2(983);
          var Driver = {
            client: function(url, options) {
              options = options || {};
              if (options.masking === void 0) options.masking = true;
              return new Client(url, options);
            },
            server: function(options) {
              options = options || {};
              if (options.requireMasking === void 0) options.requireMasking = true;
              return new Server(options);
            },
            http: function() {
              return Server.http.apply(Server, arguments);
            },
            isSecureRequest: function(request) {
              return Server.isSecureRequest(request);
            },
            isWebSocket: function(request) {
              return Base.isWebSocket(request);
            },
            validateOptions: function(options, validKeys) {
              Base.validateOptions(options, validKeys);
            }
          };
          module2.exports = Driver;
        },
        /***/
        369(module2, __unused_webpack_exports, __webpack_require__2) {
          var Buffer2 = __webpack_require__2(891).Buffer, Emitter = __webpack_require__2(434).EventEmitter, util = __webpack_require__2(23), streams = __webpack_require__2(578), Headers = __webpack_require__2(160), Reader = __webpack_require__2(212);
          var Base = function(request, url, options) {
            Emitter.call(this);
            Base.validateOptions(options || {}, ["maxLength", "masking", "requireMasking", "protocols"]);
            this._request = request;
            this._reader = new Reader();
            this._options = options || {};
            this._maxLength = this._options.maxLength || this.MAX_LENGTH;
            this._headers = new Headers();
            this.__queue = [];
            this.readyState = 0;
            this.url = url;
            this.io = new streams.IO(this);
            this.messages = new streams.Messages(this);
            this._bindEventListeners();
          };
          util.inherits(Base, Emitter);
          Base.isWebSocket = function(request) {
            var connection = request.headers.connection || "", upgrade = request.headers.upgrade || "";
            return request.method === "GET" && connection.toLowerCase().split(/ *, */).indexOf("upgrade") >= 0 && upgrade.toLowerCase() === "websocket";
          };
          Base.validateOptions = function(options, validKeys) {
            for (var key2 in options) {
              if (validKeys.indexOf(key2) < 0)
                throw new Error("Unrecognized option: " + key2);
            }
          };
          var instance = {
            // This is 64MB, small enough for an average VPS to handle without
            // crashing from process out of memory
            MAX_LENGTH: 67108863,
            STATES: ["connecting", "open", "closing", "closed"],
            _bindEventListeners: function() {
              var self2 = this;
              this.messages.on("error", function() {
              });
              this.on("message", function(event) {
                var messages = self2.messages;
                if (messages.readable) messages.emit("data", event.data);
              });
              this.on("error", function(error) {
                var messages = self2.messages;
                if (messages.readable) messages.emit("error", error);
              });
              this.on("close", function() {
                var messages = self2.messages;
                if (!messages.readable) return;
                messages.readable = messages.writable = false;
                messages.emit("end");
              });
            },
            getState: function() {
              return this.STATES[this.readyState] || null;
            },
            addExtension: function(extension) {
              return false;
            },
            setHeader: function(name, value) {
              if (this.readyState > 0) return false;
              this._headers.set(name, value);
              return true;
            },
            start: function() {
              if (this.readyState !== 0) return false;
              if (!Base.isWebSocket(this._request))
                return this._failHandshake(new Error("Not a WebSocket request"));
              var response;
              try {
                response = this._handshakeResponse();
              } catch (error) {
                return this._failHandshake(error);
              }
              this._write(response);
              if (this._stage !== -1) this._open();
              return true;
            },
            _failHandshake: function(error) {
              var headers = new Headers();
              headers.set("Content-Type", "text/plain");
              headers.set("Content-Length", Buffer2.byteLength(error.message, "utf8"));
              headers = ["HTTP/1.1 400 Bad Request", headers.toString(), error.message];
              this._write(Buffer2.from(headers.join("\r\n"), "utf8"));
              this._fail("protocol_error", error.message);
              return false;
            },
            text: function(message) {
              return this.frame(message);
            },
            binary: function(message) {
              return false;
            },
            ping: function() {
              return false;
            },
            pong: function() {
              return false;
            },
            close: function(reason, code) {
              if (this.readyState !== 1) return false;
              this.readyState = 3;
              this.emit("close", new Base.CloseEvent(null, null));
              return true;
            },
            _open: function() {
              this.readyState = 1;
              this.__queue.forEach(function(args) {
                this.frame.apply(this, args);
              }, this);
              this.__queue = [];
              this.emit("open", new Base.OpenEvent());
            },
            _queue: function(message) {
              this.__queue.push(message);
              return true;
            },
            _write: function(chunk) {
              var io = this.io;
              if (io.readable) io.emit("data", chunk);
            },
            _fail: function(type, message) {
              this.readyState = 2;
              this.emit("error", new Error(message));
              this.close();
            }
          };
          for (var key in instance)
            Base.prototype[key] = instance[key];
          Base.ConnectEvent = function() {
          };
          Base.OpenEvent = function() {
          };
          Base.CloseEvent = function(code, reason) {
            this.code = code;
            this.reason = reason;
          };
          Base.MessageEvent = function(data) {
            this.data = data;
          };
          Base.PingEvent = function(data) {
            this.data = data;
          };
          Base.PongEvent = function(data) {
            this.data = data;
          };
          module2.exports = Base;
        },
        /***/
        483(module2, __unused_webpack_exports, __webpack_require__2) {
          var Buffer2 = __webpack_require__2(891).Buffer, crypto = __webpack_require__2(982), url = __webpack_require__2(16), util = __webpack_require__2(23), HttpParser = __webpack_require__2(565), Base = __webpack_require__2(369), Hybi = __webpack_require__2(518), Proxy = __webpack_require__2(662);
          var Client = function(_url, options) {
            this.version = "hybi-" + Hybi.VERSION;
            Hybi.call(this, null, _url, options);
            this.readyState = -1;
            this._key = Client.generateKey();
            this._accept = Hybi.generateAccept(this._key);
            this._http = new HttpParser("response");
            var uri = url.parse(this.url), auth = uri.auth && Buffer2.from(uri.auth, "utf8").toString("base64");
            if (this.VALID_PROTOCOLS.indexOf(uri.protocol) < 0)
              throw new Error(this.url + " is not a valid WebSocket URL");
            this._pathname = (uri.pathname || "/") + (uri.search || "");
            this._headers.set("Host", uri.host);
            this._headers.set("Upgrade", "websocket");
            this._headers.set("Connection", "Upgrade");
            this._headers.set("Sec-WebSocket-Key", this._key);
            this._headers.set("Sec-WebSocket-Version", Hybi.VERSION);
            if (this._protocols.length > 0)
              this._headers.set("Sec-WebSocket-Protocol", this._protocols.join(", "));
            if (auth)
              this._headers.set("Authorization", "Basic " + auth);
          };
          util.inherits(Client, Hybi);
          Client.generateKey = function() {
            return crypto.randomBytes(16).toString("base64");
          };
          var instance = {
            VALID_PROTOCOLS: ["ws:", "wss:"],
            proxy: function(origin, options) {
              return new Proxy(this, origin, options);
            },
            start: function() {
              if (this.readyState !== -1) return false;
              this._write(this._handshakeRequest());
              this.readyState = 0;
              return true;
            },
            parse: function(chunk) {
              if (this.readyState === 3) return;
              if (this.readyState > 0) return Hybi.prototype.parse.call(this, chunk);
              this._http.parse(chunk);
              if (!this._http.isComplete()) return;
              this._validateHandshake();
              if (this.readyState === 3) return;
              this._open();
              this.parse(this._http.body);
            },
            _handshakeRequest: function() {
              var extensions = this._extensions.generateOffer();
              if (extensions)
                this._headers.set("Sec-WebSocket-Extensions", extensions);
              var start = "GET " + this._pathname + " HTTP/1.1", headers = [start, this._headers.toString(), ""];
              return Buffer2.from(headers.join("\r\n"), "utf8");
            },
            _failHandshake: function(message) {
              message = "Error during WebSocket handshake: " + message;
              this.readyState = 3;
              this.emit("error", new Error(message));
              this.emit("close", new Base.CloseEvent(this.ERRORS.protocol_error, message));
            },
            _validateHandshake: function() {
              this.statusCode = this._http.statusCode;
              this.headers = this._http.headers;
              if (this._http.error)
                return this._failHandshake(this._http.error.message);
              if (this._http.statusCode !== 101)
                return this._failHandshake("Unexpected response code: " + this._http.statusCode);
              var headers = this._http.headers, upgrade = headers["upgrade"] || "", connection = headers["connection"] || "", accept = headers["sec-websocket-accept"] || "", protocol = headers["sec-websocket-protocol"] || "";
              if (upgrade === "")
                return this._failHandshake("'Upgrade' header is missing");
              if (upgrade.toLowerCase() !== "websocket")
                return this._failHandshake("'Upgrade' header value is not 'WebSocket'");
              if (connection === "")
                return this._failHandshake("'Connection' header is missing");
              if (connection.toLowerCase() !== "upgrade")
                return this._failHandshake("'Connection' header value is not 'Upgrade'");
              if (accept !== this._accept)
                return this._failHandshake("Sec-WebSocket-Accept mismatch");
              this.protocol = null;
              if (protocol !== "") {
                if (this._protocols.indexOf(protocol) < 0)
                  return this._failHandshake("Sec-WebSocket-Protocol mismatch");
                else
                  this.protocol = protocol;
              }
              try {
                this._extensions.activate(this.headers["sec-websocket-extensions"]);
              } catch (e) {
                return this._failHandshake(e.message);
              }
            }
          };
          for (var key in instance)
            Client.prototype[key] = instance[key];
          module2.exports = Client;
        },
        /***/
        61(module2, __unused_webpack_exports, __webpack_require__2) {
          var Buffer2 = __webpack_require__2(891).Buffer, Base = __webpack_require__2(369), util = __webpack_require__2(23);
          var Draft75 = function(request, url, options) {
            Base.apply(this, arguments);
            this._stage = 0;
            this.version = "hixie-75";
            this._headers.set("Upgrade", "WebSocket");
            this._headers.set("Connection", "Upgrade");
            this._headers.set("WebSocket-Origin", this._request.headers.origin);
            this._headers.set("WebSocket-Location", this.url);
          };
          util.inherits(Draft75, Base);
          var instance = {
            close: function() {
              if (this.readyState === 3) return false;
              this.readyState = 3;
              this.emit("close", new Base.CloseEvent(null, null));
              return true;
            },
            parse: function(chunk) {
              if (this.readyState > 1) return;
              this._reader.put(chunk);
              this._reader.eachByte(function(octet) {
                var message;
                switch (this._stage) {
                  case -1:
                    this._body.push(octet);
                    this._sendHandshakeBody();
                    break;
                  case 0:
                    this._parseLeadingByte(octet);
                    break;
                  case 1:
                    this._length = (octet & 127) + 128 * this._length;
                    if (this._closing && this._length === 0) {
                      return this.close();
                    } else if ((octet & 128) !== 128) {
                      if (this._length === 0) {
                        this._stage = 0;
                      } else {
                        this._skipped = 0;
                        this._stage = 2;
                      }
                    }
                    break;
                  case 2:
                    if (octet === 255) {
                      this._stage = 0;
                      message = Buffer2.from(this._buffer).toString("utf8", 0, this._buffer.length);
                      this.emit("message", new Base.MessageEvent(message));
                    } else {
                      if (this._length) {
                        this._skipped += 1;
                        if (this._skipped === this._length)
                          this._stage = 0;
                      } else {
                        this._buffer.push(octet);
                        if (this._buffer.length > this._maxLength) return this.close();
                      }
                    }
                    break;
                }
              }, this);
            },
            frame: function(buffer) {
              if (this.readyState === 0) return this._queue([buffer]);
              if (this.readyState > 1) return false;
              if (typeof buffer !== "string") buffer = buffer.toString();
              var length = Buffer2.byteLength(buffer), frame = Buffer2.allocUnsafe(length + 2);
              frame[0] = 0;
              frame.write(buffer, 1);
              frame[frame.length - 1] = 255;
              this._write(frame);
              return true;
            },
            _handshakeResponse: function() {
              var start = "HTTP/1.1 101 Web Socket Protocol Handshake", headers = [start, this._headers.toString(), ""];
              return Buffer2.from(headers.join("\r\n"), "utf8");
            },
            _parseLeadingByte: function(octet) {
              if ((octet & 128) === 128) {
                this._length = 0;
                this._stage = 1;
              } else {
                delete this._length;
                delete this._skipped;
                this._buffer = [];
                this._stage = 2;
              }
            }
          };
          for (var key in instance)
            Draft75.prototype[key] = instance[key];
          module2.exports = Draft75;
        },
        /***/
        476(module2, __unused_webpack_exports, __webpack_require__2) {
          var Buffer2 = __webpack_require__2(891).Buffer, Base = __webpack_require__2(369), Draft75 = __webpack_require__2(61), crypto = __webpack_require__2(982), util = __webpack_require__2(23);
          var numberFromKey = function(key2) {
            return parseInt((key2.match(/[0-9]/g) || []).join(""), 10);
          };
          var spacesInKey = function(key2) {
            return (key2.match(/ /g) || []).length;
          };
          var Draft76 = function(request, url, options) {
            Draft75.apply(this, arguments);
            this._stage = -1;
            this._body = [];
            this.version = "hixie-76";
            this._headers.clear();
            this._headers.set("Upgrade", "WebSocket");
            this._headers.set("Connection", "Upgrade");
            this._headers.set("Sec-WebSocket-Origin", this._request.headers.origin);
            this._headers.set("Sec-WebSocket-Location", this.url);
          };
          util.inherits(Draft76, Draft75);
          var instance = {
            BODY_SIZE: 8,
            start: function() {
              if (!Draft75.prototype.start.call(this)) return false;
              this._started = true;
              this._sendHandshakeBody();
              return true;
            },
            close: function() {
              if (this.readyState === 3) return false;
              if (this.readyState === 1) this._write(Buffer2.from([255, 0]));
              this.readyState = 3;
              this.emit("close", new Base.CloseEvent(null, null));
              return true;
            },
            _handshakeResponse: function() {
              var headers = this._request.headers, key1 = headers["sec-websocket-key1"], key2 = headers["sec-websocket-key2"];
              if (!key1) throw new Error("Missing required header: Sec-WebSocket-Key1");
              if (!key2) throw new Error("Missing required header: Sec-WebSocket-Key2");
              var number1 = numberFromKey(key1), spaces1 = spacesInKey(key1), number2 = numberFromKey(key2), spaces2 = spacesInKey(key2);
              if (number1 % spaces1 !== 0 || number2 % spaces2 !== 0)
                throw new Error("Client sent invalid Sec-WebSocket-Key headers");
              this._keyValues = [number1 / spaces1, number2 / spaces2];
              var start = "HTTP/1.1 101 WebSocket Protocol Handshake", headers = [start, this._headers.toString(), ""];
              return Buffer2.from(headers.join("\r\n"), "binary");
            },
            _handshakeSignature: function() {
              if (this._body.length < this.BODY_SIZE) return null;
              var md5 = crypto.createHash("md5"), buffer = Buffer2.allocUnsafe(8 + this.BODY_SIZE);
              buffer.writeUInt32BE(this._keyValues[0], 0);
              buffer.writeUInt32BE(this._keyValues[1], 4);
              Buffer2.from(this._body).copy(buffer, 8, 0, this.BODY_SIZE);
              md5.update(buffer);
              return Buffer2.from(md5.digest("binary"), "binary");
            },
            _sendHandshakeBody: function() {
              if (!this._started) return;
              var signature = this._handshakeSignature();
              if (!signature) return;
              this._write(signature);
              this._stage = 0;
              this._open();
              if (this._body.length > this.BODY_SIZE)
                this.parse(this._body.slice(this.BODY_SIZE));
            },
            _parseLeadingByte: function(octet) {
              if (octet !== 255)
                return Draft75.prototype._parseLeadingByte.call(this, octet);
              this._closing = true;
              this._length = 0;
              this._stage = 1;
            }
          };
          for (var key in instance)
            Draft76.prototype[key] = instance[key];
          module2.exports = Draft76;
        },
        /***/
        160(module2) {
          var Headers = function() {
            this.clear();
          };
          Headers.prototype.ALLOWED_DUPLICATES = ["set-cookie", "set-cookie2", "warning", "www-authenticate"];
          Headers.prototype.clear = function() {
            this._sent = {};
            this._lines = [];
          };
          Headers.prototype.set = function(name, value) {
            if (value === void 0) return;
            name = this._strip(name);
            value = this._strip(value);
            var key = name.toLowerCase();
            if (!this._sent.hasOwnProperty(key) || this.ALLOWED_DUPLICATES.indexOf(key) >= 0) {
              this._sent[key] = true;
              this._lines.push(name + ": " + value + "\r\n");
            }
          };
          Headers.prototype.toString = function() {
            return this._lines.join("");
          };
          Headers.prototype._strip = function(string) {
            return string.toString().replace(/^ */, "").replace(/ *$/, "");
          };
          module2.exports = Headers;
        },
        /***/
        518(module2, __unused_webpack_exports, __webpack_require__2) {
          var Buffer2 = __webpack_require__2(891).Buffer, crypto = __webpack_require__2(982), util = __webpack_require__2(23), Extensions = __webpack_require__2(769), Base = __webpack_require__2(369), Frame = __webpack_require__2(68), Message = __webpack_require__2(814);
          var Hybi = function(request, url, options) {
            Base.apply(this, arguments);
            this._extensions = new Extensions();
            this._stage = 0;
            this._masking = this._options.masking;
            this._protocols = this._options.protocols || [];
            this._requireMasking = this._options.requireMasking;
            this._pingCallbacks = {};
            if (typeof this._protocols === "string")
              this._protocols = this._protocols.split(/ *, */);
            if (!this._request) return;
            var protos = this._request.headers["sec-websocket-protocol"], supported = this._protocols;
            if (protos !== void 0) {
              if (typeof protos === "string") protos = protos.split(/ *, */);
              this.protocol = protos.filter(function(p2) {
                return supported.indexOf(p2) >= 0;
              })[0];
            }
            this.version = "hybi-" + Hybi.VERSION;
          };
          util.inherits(Hybi, Base);
          Hybi.VERSION = "13";
          Hybi.mask = function(payload, mask, offset) {
            if (!mask || mask.length === 0) return payload;
            offset = offset || 0;
            for (var i = 0, n = payload.length - offset; i < n; i++) {
              payload[offset + i] = payload[offset + i] ^ mask[i % 4];
            }
            return payload;
          };
          Hybi.generateAccept = function(key2) {
            var sha1 = crypto.createHash("sha1");
            sha1.update(key2 + Hybi.GUID);
            return sha1.digest("base64");
          };
          Hybi.GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
          var instance = {
            FIN: 128,
            MASK: 128,
            RSV1: 64,
            RSV2: 32,
            RSV3: 16,
            OPCODE: 15,
            LENGTH: 127,
            OPCODES: {
              continuation: 0,
              text: 1,
              binary: 2,
              close: 8,
              ping: 9,
              pong: 10
            },
            OPCODE_CODES: [0, 1, 2, 8, 9, 10],
            MESSAGE_OPCODES: [0, 1, 2],
            OPENING_OPCODES: [1, 2],
            ERRORS: {
              normal_closure: 1e3,
              going_away: 1001,
              protocol_error: 1002,
              unacceptable: 1003,
              encoding_error: 1007,
              policy_violation: 1008,
              too_large: 1009,
              extension_error: 1010,
              unexpected_condition: 1011
            },
            ERROR_CODES: [1e3, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011],
            DEFAULT_ERROR_CODE: 1e3,
            MIN_RESERVED_ERROR: 3e3,
            MAX_RESERVED_ERROR: 4999,
            // http://www.w3.org/International/questions/qa-forms-utf-8.en.php
            UTF8_MATCH: /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/,
            addExtension: function(extension) {
              this._extensions.add(extension);
              return true;
            },
            parse: function(chunk) {
              this._reader.put(chunk);
              var buffer = true;
              while (buffer) {
                switch (this._stage) {
                  case 0:
                    buffer = this._reader.read(1);
                    if (buffer) this._parseOpcode(buffer[0]);
                    break;
                  case 1:
                    buffer = this._reader.read(1);
                    if (buffer) this._parseLength(buffer[0]);
                    break;
                  case 2:
                    buffer = this._reader.read(this._frame.lengthBytes);
                    if (buffer) this._parseExtendedLength(buffer);
                    break;
                  case 3:
                    buffer = this._reader.read(4);
                    if (buffer) {
                      this._stage = 4;
                      this._frame.maskingKey = buffer;
                    }
                    break;
                  case 4:
                    buffer = this._reader.read(this._frame.length);
                    if (buffer) {
                      this._stage = 0;
                      this._emitFrame(buffer);
                    }
                    break;
                  default:
                    buffer = null;
                }
              }
            },
            text: function(message) {
              if (this.readyState > 1) return false;
              return this.frame(message, "text");
            },
            binary: function(message) {
              if (this.readyState > 1) return false;
              return this.frame(message, "binary");
            },
            ping: function(message, callback) {
              if (this.readyState > 1) return false;
              message = message || "";
              if (callback) this._pingCallbacks[message] = callback;
              return this.frame(message, "ping");
            },
            pong: function(message) {
              if (this.readyState > 1) return false;
              message = message || "";
              return this.frame(message, "pong");
            },
            close: function(reason, code) {
              reason = reason || "";
              code = code || this.ERRORS.normal_closure;
              if (this.readyState <= 0) {
                this.readyState = 3;
                this.emit("close", new Base.CloseEvent(code, reason));
                return true;
              } else if (this.readyState === 1) {
                this.readyState = 2;
                this._extensions.close(function() {
                  this.frame(reason, "close", code);
                }, this);
                return true;
              } else {
                return false;
              }
            },
            frame: function(buffer, type, code) {
              if (this.readyState <= 0) return this._queue([buffer, type, code]);
              if (this.readyState > 2) return false;
              if (buffer instanceof Array) buffer = Buffer2.from(buffer);
              if (typeof buffer === "number") buffer = buffer.toString();
              var message = new Message(), isText = typeof buffer === "string", payload, copy;
              message.rsv1 = message.rsv2 = message.rsv3 = false;
              message.opcode = this.OPCODES[type || (isText ? "text" : "binary")];
              payload = isText ? Buffer2.from(buffer, "utf8") : buffer;
              if (code) {
                copy = payload;
                payload = Buffer2.allocUnsafe(2 + copy.length);
                payload.writeUInt16BE(code, 0);
                copy.copy(payload, 2);
              }
              message.data = payload;
              var onMessageReady = function(message2) {
                var frame = new Frame();
                frame.final = true;
                frame.rsv1 = message2.rsv1;
                frame.rsv2 = message2.rsv2;
                frame.rsv3 = message2.rsv3;
                frame.opcode = message2.opcode;
                frame.masked = !!this._masking;
                frame.length = message2.data.length;
                frame.payload = message2.data;
                if (frame.masked) frame.maskingKey = crypto.randomBytes(4);
                this._sendFrame(frame);
              };
              if (this.MESSAGE_OPCODES.indexOf(message.opcode) >= 0)
                this._extensions.processOutgoingMessage(message, function(error, message2) {
                  if (error) return this._fail("extension_error", error.message);
                  onMessageReady.call(this, message2);
                }, this);
              else
                onMessageReady.call(this, message);
              return true;
            },
            _sendFrame: function(frame) {
              var length = frame.length, header = length <= 125 ? 2 : length <= 65535 ? 4 : 10, offset = header + (frame.masked ? 4 : 0), buffer = Buffer2.allocUnsafe(offset + length), masked = frame.masked ? this.MASK : 0;
              buffer[0] = (frame.final ? this.FIN : 0) | (frame.rsv1 ? this.RSV1 : 0) | (frame.rsv2 ? this.RSV2 : 0) | (frame.rsv3 ? this.RSV3 : 0) | frame.opcode;
              if (length <= 125) {
                buffer[1] = masked | length;
              } else if (length <= 65535) {
                buffer[1] = masked | 126;
                buffer.writeUInt16BE(length, 2);
              } else {
                buffer[1] = masked | 127;
                buffer.writeUInt32BE(Math.floor(length / 4294967296), 2);
                buffer.writeUInt32BE(length % 4294967296, 6);
              }
              frame.payload.copy(buffer, offset);
              if (frame.masked) {
                frame.maskingKey.copy(buffer, header);
                Hybi.mask(buffer, frame.maskingKey, offset);
              }
              this._write(buffer);
            },
            _handshakeResponse: function() {
              var secKey = this._request.headers["sec-websocket-key"], version = this._request.headers["sec-websocket-version"];
              if (version !== Hybi.VERSION)
                throw new Error("Unsupported WebSocket version: " + version);
              if (typeof secKey !== "string")
                throw new Error("Missing handshake request header: Sec-WebSocket-Key");
              this._headers.set("Upgrade", "websocket");
              this._headers.set("Connection", "Upgrade");
              this._headers.set("Sec-WebSocket-Accept", Hybi.generateAccept(secKey));
              if (this.protocol) this._headers.set("Sec-WebSocket-Protocol", this.protocol);
              var extensions = this._extensions.generateResponse(this._request.headers["sec-websocket-extensions"]);
              if (extensions) this._headers.set("Sec-WebSocket-Extensions", extensions);
              var start = "HTTP/1.1 101 Switching Protocols", headers = [start, this._headers.toString(), ""];
              return Buffer2.from(headers.join("\r\n"), "utf8");
            },
            _shutdown: function(code, reason, error) {
              delete this._frame;
              delete this._message;
              this._stage = 5;
              var sendCloseFrame = this.readyState === 1;
              this.readyState = 2;
              this._extensions.close(function() {
                if (sendCloseFrame) this.frame(reason, "close", code);
                this.readyState = 3;
                if (error) this.emit("error", new Error(reason));
                this.emit("close", new Base.CloseEvent(code, reason));
              }, this);
            },
            _fail: function(type, message) {
              if (this.readyState > 1) return;
              this._shutdown(this.ERRORS[type], message, true);
            },
            _parseOpcode: function(octet) {
              var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
                return (octet & rsv) === rsv;
              });
              var frame = this._frame = new Frame();
              frame.final = (octet & this.FIN) === this.FIN;
              frame.rsv1 = rsvs[0];
              frame.rsv2 = rsvs[1];
              frame.rsv3 = rsvs[2];
              frame.opcode = octet & this.OPCODE;
              this._stage = 1;
              if (!this._extensions.validFrameRsv(frame))
                return this._fail(
                  "protocol_error",
                  "One or more reserved bits are on: reserved1 = " + (frame.rsv1 ? 1 : 0) + ", reserved2 = " + (frame.rsv2 ? 1 : 0) + ", reserved3 = " + (frame.rsv3 ? 1 : 0)
                );
              if (this.OPCODE_CODES.indexOf(frame.opcode) < 0)
                return this._fail("protocol_error", "Unrecognized frame opcode: " + frame.opcode);
              if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && !frame.final)
                return this._fail("protocol_error", "Received fragmented control frame: opcode = " + frame.opcode);
              if (this._message && this.OPENING_OPCODES.indexOf(frame.opcode) >= 0)
                return this._fail("protocol_error", "Received new data frame but previous continuous frame is unfinished");
            },
            _parseLength: function(octet) {
              var frame = this._frame;
              frame.masked = (octet & this.MASK) === this.MASK;
              frame.length = octet & this.LENGTH;
              if (frame.length >= 0 && frame.length <= 125) {
                this._stage = frame.masked ? 3 : 4;
                if (!this._checkFrameLength()) return;
              } else {
                this._stage = 2;
                frame.lengthBytes = frame.length === 126 ? 2 : 8;
              }
              if (this._requireMasking && !frame.masked)
                return this._fail("unacceptable", "Received unmasked frame but masking is required");
            },
            _parseExtendedLength: function(buffer) {
              var frame = this._frame;
              frame.length = this._readUInt(buffer);
              this._stage = frame.masked ? 3 : 4;
              if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && frame.length > 125)
                return this._fail("protocol_error", "Received control frame having too long payload: " + frame.length);
              if (!this._checkFrameLength()) return;
            },
            _checkFrameLength: function() {
              var length = this._message ? this._message.length : 0;
              if (length + this._frame.length > this._maxLength) {
                this._fail("too_large", "WebSocket frame length too large");
                return false;
              } else {
                return true;
              }
            },
            _emitFrame: function(buffer) {
              var frame = this._frame, payload = frame.payload = Hybi.mask(buffer, frame.maskingKey), opcode = frame.opcode, message, code, reason, callbacks, callback;
              delete this._frame;
              if (opcode === this.OPCODES.continuation) {
                if (!this._message) return this._fail("protocol_error", "Received unexpected continuation frame");
                this._message.pushFrame(frame);
              }
              if (opcode === this.OPCODES.text || opcode === this.OPCODES.binary) {
                this._message = new Message();
                this._message.pushFrame(frame);
              }
              if (frame.final && this.MESSAGE_OPCODES.indexOf(opcode) >= 0)
                return this._emitMessage(this._message);
              if (opcode === this.OPCODES.close) {
                code = payload.length >= 2 ? payload.readUInt16BE(0) : null;
                reason = payload.length > 2 ? this._encode(payload.slice(2)) : null;
                if (!(payload.length === 0) && !(code !== null && code >= this.MIN_RESERVED_ERROR && code <= this.MAX_RESERVED_ERROR) && this.ERROR_CODES.indexOf(code) < 0)
                  code = this.ERRORS.protocol_error;
                if (payload.length > 125 || payload.length > 2 && !reason)
                  code = this.ERRORS.protocol_error;
                this._shutdown(code || this.DEFAULT_ERROR_CODE, reason || "");
              }
              if (opcode === this.OPCODES.ping) {
                this.frame(payload, "pong");
                this.emit("ping", new Base.PingEvent(payload.toString()));
              }
              if (opcode === this.OPCODES.pong) {
                callbacks = this._pingCallbacks;
                message = this._encode(payload);
                callback = callbacks[message];
                delete callbacks[message];
                if (callback) callback();
                this.emit("pong", new Base.PongEvent(payload.toString()));
              }
            },
            _emitMessage: function(message) {
              var message = this._message;
              message.read();
              delete this._message;
              this._extensions.processIncomingMessage(message, function(error, message2) {
                if (error) return this._fail("extension_error", error.message);
                var payload = message2.data;
                if (message2.opcode === this.OPCODES.text) payload = this._encode(payload);
                if (payload === null)
                  return this._fail("encoding_error", "Could not decode a text frame as UTF-8");
                else
                  this.emit("message", new Base.MessageEvent(payload));
              }, this);
            },
            _encode: function(buffer) {
              try {
                var string = buffer.toString("binary", 0, buffer.length);
                if (!this.UTF8_MATCH.test(string)) return null;
              } catch (e) {
              }
              return buffer.toString("utf8", 0, buffer.length);
            },
            _readUInt: function(buffer) {
              if (buffer.length === 2) return buffer.readUInt16BE(0);
              return buffer.readUInt32BE(0) * 4294967296 + buffer.readUInt32BE(4);
            }
          };
          for (var key in instance)
            Hybi.prototype[key] = instance[key];
          module2.exports = Hybi;
        },
        /***/
        68(module2) {
          var Frame = function() {
          };
          var instance = {
            final: false,
            rsv1: false,
            rsv2: false,
            rsv3: false,
            opcode: null,
            masked: false,
            maskingKey: null,
            lengthBytes: 1,
            length: 0,
            payload: null
          };
          for (var key in instance)
            Frame.prototype[key] = instance[key];
          module2.exports = Frame;
        },
        /***/
        814(module2, __unused_webpack_exports, __webpack_require__2) {
          var Buffer2 = __webpack_require__2(891).Buffer;
          var Message = function() {
            this.rsv1 = false;
            this.rsv2 = false;
            this.rsv3 = false;
            this.opcode = null;
            this.length = 0;
            this._chunks = [];
          };
          var instance = {
            read: function() {
              return this.data = this.data || Buffer2.concat(this._chunks, this.length);
            },
            pushFrame: function(frame) {
              this.rsv1 = this.rsv1 || frame.rsv1;
              this.rsv2 = this.rsv2 || frame.rsv2;
              this.rsv3 = this.rsv3 || frame.rsv3;
              if (this.opcode === null) this.opcode = frame.opcode;
              this._chunks.push(frame.payload);
              this.length += frame.length;
            }
          };
          for (var key in instance)
            Message.prototype[key] = instance[key];
          module2.exports = Message;
        },
        /***/
        662(module2, __unused_webpack_exports, __webpack_require__2) {
          var Buffer2 = __webpack_require__2(891).Buffer, Stream = __webpack_require__2(203).Stream, url = __webpack_require__2(16), util = __webpack_require__2(23), Base = __webpack_require__2(369), Headers = __webpack_require__2(160), HttpParser = __webpack_require__2(565);
          var PORTS = { "ws:": 80, "wss:": 443 };
          var Proxy = function(client, origin, options) {
            this._client = client;
            this._http = new HttpParser("response");
            this._origin = typeof client.url === "object" ? client.url : url.parse(client.url);
            this._url = typeof origin === "object" ? origin : url.parse(origin);
            this._options = options || {};
            this._state = 0;
            this.readable = this.writable = true;
            this._paused = false;
            this._headers = new Headers();
            this._headers.set("Host", this._origin.host);
            this._headers.set("Connection", "keep-alive");
            this._headers.set("Proxy-Connection", "keep-alive");
            var auth = this._url.auth && Buffer2.from(this._url.auth, "utf8").toString("base64");
            if (auth) this._headers.set("Proxy-Authorization", "Basic " + auth);
          };
          util.inherits(Proxy, Stream);
          var instance = {
            setHeader: function(name, value) {
              if (this._state !== 0) return false;
              this._headers.set(name, value);
              return true;
            },
            start: function() {
              if (this._state !== 0) return false;
              this._state = 1;
              var origin = this._origin, port = origin.port || PORTS[origin.protocol], start = "CONNECT " + origin.hostname + ":" + port + " HTTP/1.1";
              var headers = [start, this._headers.toString(), ""];
              this.emit("data", Buffer2.from(headers.join("\r\n"), "utf8"));
              return true;
            },
            pause: function() {
              this._paused = true;
            },
            resume: function() {
              this._paused = false;
              this.emit("drain");
            },
            write: function(chunk) {
              if (!this.writable) return false;
              this._http.parse(chunk);
              if (!this._http.isComplete()) return !this._paused;
              this.statusCode = this._http.statusCode;
              this.headers = this._http.headers;
              if (this.statusCode === 200) {
                this.emit("connect", new Base.ConnectEvent());
              } else {
                var message = "Can't establish a connection to the server at " + this._origin.href;
                this.emit("error", new Error(message));
              }
              this.end();
              return !this._paused;
            },
            end: function(chunk) {
              if (!this.writable) return;
              if (chunk !== void 0) this.write(chunk);
              this.readable = this.writable = false;
              this.emit("close");
              this.emit("end");
            },
            destroy: function() {
              this.end();
            }
          };
          for (var key in instance)
            Proxy.prototype[key] = instance[key];
          module2.exports = Proxy;
        },
        /***/
        983(module2, __unused_webpack_exports, __webpack_require__2) {
          var util = __webpack_require__2(23), HttpParser = __webpack_require__2(565), Base = __webpack_require__2(369), Draft75 = __webpack_require__2(61), Draft76 = __webpack_require__2(476), Hybi = __webpack_require__2(518);
          var Server = function(options) {
            Base.call(this, null, null, options);
            this._http = new HttpParser("request");
          };
          util.inherits(Server, Base);
          var instance = {
            EVENTS: ["open", "message", "error", "close", "ping", "pong"],
            _bindEventListeners: function() {
              this.messages.on("error", function() {
              });
              this.on("error", function() {
              });
            },
            parse: function(chunk) {
              if (this._delegate) return this._delegate.parse(chunk);
              this._http.parse(chunk);
              if (!this._http.isComplete()) return;
              this.method = this._http.method;
              this.url = this._http.url;
              this.headers = this._http.headers;
              this.body = this._http.body;
              var self2 = this;
              this._delegate = Server.http(this, this._options);
              this._delegate.messages = this.messages;
              this._delegate.io = this.io;
              this._open();
              this.EVENTS.forEach(function(event) {
                this._delegate.on(event, function(e) {
                  self2.emit(event, e);
                });
              }, this);
              this.protocol = this._delegate.protocol;
              this.version = this._delegate.version;
              this.parse(this._http.body);
              this.emit("connect", new Base.ConnectEvent());
            },
            _open: function() {
              this.__queue.forEach(function(msg) {
                this._delegate[msg[0]].apply(this._delegate, msg[1]);
              }, this);
              this.__queue = [];
            }
          };
          ["addExtension", "setHeader", "start", "frame", "text", "binary", "ping", "close"].forEach(function(method) {
            instance[method] = function() {
              if (this._delegate) {
                return this._delegate[method].apply(this._delegate, arguments);
              } else {
                this.__queue.push([method, arguments]);
                return true;
              }
            };
          });
          for (var key in instance)
            Server.prototype[key] = instance[key];
          Server.isSecureRequest = function(request) {
            if (request.connection && request.connection.authorized !== void 0) return true;
            if (request.socket && request.socket.secure) return true;
            var headers = request.headers;
            if (!headers) return false;
            if (headers["https"] === "on") return true;
            if (headers["x-forwarded-ssl"] === "on") return true;
            if (headers["x-forwarded-scheme"] === "https") return true;
            if (headers["x-forwarded-proto"] === "https") return true;
            return false;
          };
          Server.determineUrl = function(request) {
            var scheme = this.isSecureRequest(request) ? "wss:" : "ws:";
            return scheme + "//" + request.headers.host + request.url;
          };
          Server.http = function(request, options) {
            options = options || {};
            if (options.requireMasking === void 0) options.requireMasking = true;
            var headers = request.headers, version = headers["sec-websocket-version"], key2 = headers["sec-websocket-key"], key1 = headers["sec-websocket-key1"], key22 = headers["sec-websocket-key2"], url = this.determineUrl(request);
            if (version || key2)
              return new Hybi(request, url, options);
            else if (key1 || key22)
              return new Draft76(request, url, options);
            else
              return new Draft75(request, url, options);
          };
          module2.exports = Server;
        },
        /***/
        212(module2, __unused_webpack_exports, __webpack_require__2) {
          var Buffer2 = __webpack_require__2(891).Buffer;
          var StreamReader = function() {
            this._queue = [];
            this._queueSize = 0;
            this._offset = 0;
          };
          StreamReader.prototype.put = function(buffer) {
            if (!buffer || buffer.length === 0) return;
            if (!Buffer2.isBuffer(buffer)) buffer = Buffer2.from(buffer);
            this._queue.push(buffer);
            this._queueSize += buffer.length;
          };
          StreamReader.prototype.read = function(length) {
            if (length > this._queueSize) return null;
            if (length === 0) return Buffer2.alloc(0);
            this._queueSize -= length;
            var queue = this._queue, remain = length, first = queue[0], buffers, buffer;
            if (first.length >= length) {
              if (first.length === length) {
                return queue.shift();
              } else {
                buffer = first.slice(0, length);
                queue[0] = first.slice(length);
                return buffer;
              }
            }
            for (var i = 0, n = queue.length; i < n; i++) {
              if (remain < queue[i].length) break;
              remain -= queue[i].length;
            }
            buffers = queue.splice(0, i);
            if (remain > 0 && queue.length > 0) {
              buffers.push(queue[0].slice(0, remain));
              queue[0] = queue[0].slice(remain);
            }
            return Buffer2.concat(buffers, length);
          };
          StreamReader.prototype.eachByte = function(callback, context) {
            var buffer, n, index;
            while (this._queue.length > 0) {
              buffer = this._queue[0];
              n = buffer.length;
              while (this._offset < n) {
                index = this._offset;
                this._offset += 1;
                callback.call(context, buffer[index]);
              }
              this._offset = 0;
              this._queue.shift();
            }
          };
          module2.exports = StreamReader;
        },
        /***/
        565(module2, __unused_webpack_exports, __webpack_require__2) {
          var NodeHTTPParser = __webpack_require__2(895).e, Buffer2 = __webpack_require__2(891).Buffer;
          var TYPES = {
            request: NodeHTTPParser.REQUEST || "request",
            response: NodeHTTPParser.RESPONSE || "response"
          };
          var HttpParser = function(type) {
            this._type = type;
            this._parser = new NodeHTTPParser(TYPES[type]);
            this._complete = false;
            this.headers = {};
            var current = null, self2 = this;
            this._parser.onHeaderField = function(b2, start, length) {
              current = b2.toString("utf8", start, start + length).toLowerCase();
            };
            this._parser.onHeaderValue = function(b2, start, length) {
              var value = b2.toString("utf8", start, start + length);
              if (self2.headers.hasOwnProperty(current))
                self2.headers[current] += ", " + value;
              else
                self2.headers[current] = value;
            };
            this._parser.onHeadersComplete = this._parser[NodeHTTPParser.kOnHeadersComplete] = function(majorVersion, minorVersion, headers, method, pathname, statusCode) {
              var info = arguments[0];
              if (typeof info === "object") {
                method = info.method;
                pathname = info.url;
                statusCode = info.statusCode;
                headers = info.headers;
              }
              self2.method = typeof method === "number" ? HttpParser.METHODS[method] : method;
              self2.statusCode = statusCode;
              self2.url = pathname;
              if (!headers) return;
              for (var i = 0, n = headers.length, key, value; i < n; i += 2) {
                key = headers[i].toLowerCase();
                value = headers[i + 1];
                if (self2.headers.hasOwnProperty(key))
                  self2.headers[key] += ", " + value;
                else
                  self2.headers[key] = value;
              }
              self2._complete = true;
            };
          };
          HttpParser.METHODS = {
            0: "DELETE",
            1: "GET",
            2: "HEAD",
            3: "POST",
            4: "PUT",
            5: "CONNECT",
            6: "OPTIONS",
            7: "TRACE",
            8: "COPY",
            9: "LOCK",
            10: "MKCOL",
            11: "MOVE",
            12: "PROPFIND",
            13: "PROPPATCH",
            14: "SEARCH",
            15: "UNLOCK",
            16: "BIND",
            17: "REBIND",
            18: "UNBIND",
            19: "ACL",
            20: "REPORT",
            21: "MKACTIVITY",
            22: "CHECKOUT",
            23: "MERGE",
            24: "M-SEARCH",
            25: "NOTIFY",
            26: "SUBSCRIBE",
            27: "UNSUBSCRIBE",
            28: "PATCH",
            29: "PURGE",
            30: "MKCALENDAR",
            31: "LINK",
            32: "UNLINK"
          };
          var VERSION = process.version ? process.version.match(/[0-9]+/g).map(function(n) {
            return parseInt(n, 10);
          }) : [];
          if (VERSION[0] === 0 && VERSION[1] === 12) {
            HttpParser.METHODS[16] = "REPORT";
            HttpParser.METHODS[17] = "MKACTIVITY";
            HttpParser.METHODS[18] = "CHECKOUT";
            HttpParser.METHODS[19] = "MERGE";
            HttpParser.METHODS[20] = "M-SEARCH";
            HttpParser.METHODS[21] = "NOTIFY";
            HttpParser.METHODS[22] = "SUBSCRIBE";
            HttpParser.METHODS[23] = "UNSUBSCRIBE";
            HttpParser.METHODS[24] = "PATCH";
            HttpParser.METHODS[25] = "PURGE";
          }
          HttpParser.prototype.isComplete = function() {
            return this._complete;
          };
          HttpParser.prototype.parse = function(chunk) {
            var consumed = this._parser.execute(chunk, 0, chunk.length);
            if (typeof consumed !== "number") {
              this.error = consumed;
              this._complete = true;
              return;
            }
            if (this._complete)
              this.body = consumed < chunk.length ? chunk.slice(consumed) : Buffer2.alloc(0);
          };
          module2.exports = HttpParser;
        },
        /***/
        578(__unused_webpack_module, exports$1, __webpack_require__2) {
          var Stream = __webpack_require__2(203).Stream, util = __webpack_require__2(23);
          var IO = function(driver) {
            this.readable = this.writable = true;
            this._paused = false;
            this._driver = driver;
          };
          util.inherits(IO, Stream);
          IO.prototype.pause = function() {
            this._paused = true;
            this._driver.messages._paused = true;
          };
          IO.prototype.resume = function() {
            this._paused = false;
            this.emit("drain");
            var messages = this._driver.messages;
            messages._paused = false;
            messages.emit("drain");
          };
          IO.prototype.write = function(chunk) {
            if (!this.writable) return false;
            this._driver.parse(chunk);
            return !this._paused;
          };
          IO.prototype.end = function(chunk) {
            if (!this.writable) return;
            if (chunk !== void 0) this.write(chunk);
            this.writable = false;
            var messages = this._driver.messages;
            if (messages.readable) {
              messages.readable = messages.writable = false;
              messages.emit("end");
            }
          };
          IO.prototype.destroy = function() {
            this.end();
          };
          var Messages = function(driver) {
            this.readable = this.writable = true;
            this._paused = false;
            this._driver = driver;
          };
          util.inherits(Messages, Stream);
          Messages.prototype.pause = function() {
            this._driver.io._paused = true;
          };
          Messages.prototype.resume = function() {
            this._driver.io._paused = false;
            this._driver.io.emit("drain");
          };
          Messages.prototype.write = function(message) {
            if (!this.writable) return false;
            if (typeof message === "string") this._driver.text(message);
            else this._driver.binary(message);
            return !this._paused;
          };
          Messages.prototype.end = function(message) {
            if (message !== void 0) this.write(message);
          };
          Messages.prototype.destroy = function() {
          };
          exports$1.IO = IO;
          exports$1.Messages = Messages;
        },
        /***/
        80(module2) {
          var TOKEN = /([!#\$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+)/, NOTOKEN = /([^!#\$%&'\*\+\-\.\^_`\|~0-9A-Za-z])/g, QUOTED = /"((?:\\[\x00-\x7f]|[^\x00-\x08\x0a-\x1f\x7f"\\])*)"/, PARAM = new RegExp(TOKEN.source + "(?:=(?:" + TOKEN.source + "|" + QUOTED.source + "))?"), EXT = new RegExp(TOKEN.source + "(?: *; *" + PARAM.source + ")*", "g"), EXT_LIST = new RegExp("^" + EXT.source + "(?: *, *" + EXT.source + ")*$"), NUMBER = /^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/;
          var hasOwnProperty = Object.prototype.hasOwnProperty;
          var Parser = {
            parseHeader: function(header) {
              var offers = new Offers();
              if (header === "" || header === void 0) return offers;
              if (!EXT_LIST.test(header))
                throw new SyntaxError("Invalid Sec-WebSocket-Extensions header: " + header);
              var values = header.match(EXT);
              values.forEach(function(value) {
                var params = value.match(new RegExp(PARAM.source, "g")), name = params.shift(), offer = {};
                params.forEach(function(param) {
                  var args = param.match(PARAM), key = args[1], data;
                  if (args[2] !== void 0) {
                    data = args[2];
                  } else if (args[3] !== void 0) {
                    data = args[3].replace(/\\/g, "");
                  } else {
                    data = true;
                  }
                  if (NUMBER.test(data)) data = parseFloat(data);
                  if (hasOwnProperty.call(offer, key)) {
                    offer[key] = [].concat(offer[key]);
                    offer[key].push(data);
                  } else {
                    offer[key] = data;
                  }
                }, this);
                offers.push(name, offer);
              }, this);
              return offers;
            },
            serializeParams: function(name, params) {
              var values = [];
              var print = function(key2, value) {
                if (value instanceof Array) {
                  value.forEach(function(v2) {
                    print(key2, v2);
                  });
                } else if (value === true) {
                  values.push(key2);
                } else if (typeof value === "number") {
                  values.push(key2 + "=" + value);
                } else if (NOTOKEN.test(value)) {
                  values.push(key2 + '="' + value.replace(/"/g, '\\"') + '"');
                } else {
                  values.push(key2 + "=" + value);
                }
              };
              for (var key in params) print(key, params[key]);
              return [name].concat(values).join("; ");
            }
          };
          var Offers = function() {
            this._byName = {};
            this._inOrder = [];
          };
          Offers.prototype.push = function(name, params) {
            if (!hasOwnProperty.call(this._byName, name))
              this._byName[name] = [];
            this._byName[name].push(params);
            this._inOrder.push({ name, params });
          };
          Offers.prototype.eachOffer = function(callback, context) {
            var list = this._inOrder;
            for (var i = 0, n = list.length; i < n; i++)
              callback.call(context, list[i].name, list[i].params);
          };
          Offers.prototype.byName = function(name) {
            return this._byName[name] || [];
          };
          Offers.prototype.toArray = function() {
            return this._inOrder.slice();
          };
          module2.exports = Parser;
        },
        /***/
        152(module2, __unused_webpack_exports, __webpack_require__2) {
          var Functor = __webpack_require__2(277), Pledge = __webpack_require__2(521);
          var Cell = function(tuple) {
            this._ext = tuple[0];
            this._session = tuple[1];
            this._functors = {
              incoming: new Functor(this._session, "processIncomingMessage"),
              outgoing: new Functor(this._session, "processOutgoingMessage")
            };
          };
          Cell.prototype.pending = function(direction) {
            var functor = this._functors[direction];
            if (!functor._stopped) functor.pending += 1;
          };
          Cell.prototype.incoming = function(error, message, callback, context) {
            this._exec("incoming", error, message, callback, context);
          };
          Cell.prototype.outgoing = function(error, message, callback, context) {
            this._exec("outgoing", error, message, callback, context);
          };
          Cell.prototype.close = function() {
            this._closed = this._closed || new Pledge();
            this._doClose();
            return this._closed;
          };
          Cell.prototype._exec = function(direction, error, message, callback, context) {
            this._functors[direction].call(error, message, function(err, msg) {
              if (err) err.message = this._ext.name + ": " + err.message;
              callback.call(context, err, msg);
              this._doClose();
            }, this);
          };
          Cell.prototype._doClose = function() {
            var fin = this._functors.incoming, fout = this._functors.outgoing;
            if (!this._closed || fin.pending + fout.pending !== 0) return;
            if (this._session) this._session.close();
            this._session = null;
            this._closed.done();
          };
          module2.exports = Cell;
        },
        /***/
        277(module2, __unused_webpack_exports, __webpack_require__2) {
          var RingBuffer = __webpack_require__2(411);
          var Functor = function(session, method) {
            this._session = session;
            this._method = method;
            this._queue = new RingBuffer(Functor.QUEUE_SIZE);
            this._stopped = false;
            this.pending = 0;
          };
          Functor.QUEUE_SIZE = 8;
          Functor.prototype.call = function(error, message, callback, context) {
            if (this._stopped) return;
            var record = { error, message, callback, context, done: false }, called = false, self2 = this;
            this._queue.push(record);
            if (record.error) {
              record.done = true;
              this._stop();
              return this._flushQueue();
            }
            var handler = function(err, msg) {
              if (!(called ^ (called = true))) return;
              if (err) {
                self2._stop();
                record.error = err;
                record.message = null;
              } else {
                record.message = msg;
              }
              record.done = true;
              self2._flushQueue();
            };
            try {
              this._session[this._method](message, handler);
            } catch (err) {
              handler(err);
            }
          };
          Functor.prototype._stop = function() {
            this.pending = this._queue.length;
            this._stopped = true;
          };
          Functor.prototype._flushQueue = function() {
            var queue = this._queue, record;
            while (queue.length > 0 && queue.peek().done) {
              record = queue.shift();
              if (record.error) {
                this.pending = 0;
                queue.clear();
              } else {
                this.pending -= 1;
              }
              record.callback.call(record.context, record.error, record.message);
            }
          };
          module2.exports = Functor;
        },
        /***/
        862(module2, __unused_webpack_exports, __webpack_require__2) {
          var Cell = __webpack_require__2(152), Pledge = __webpack_require__2(521);
          var Pipeline = function(sessions) {
            this._cells = sessions.map(function(session) {
              return new Cell(session);
            });
            this._stopped = { incoming: false, outgoing: false };
          };
          Pipeline.prototype.processIncomingMessage = function(message, callback, context) {
            if (this._stopped.incoming) return;
            this._loop("incoming", this._cells.length - 1, -1, -1, message, callback, context);
          };
          Pipeline.prototype.processOutgoingMessage = function(message, callback, context) {
            if (this._stopped.outgoing) return;
            this._loop("outgoing", 0, this._cells.length, 1, message, callback, context);
          };
          Pipeline.prototype.close = function(callback, context) {
            this._stopped = { incoming: true, outgoing: true };
            var closed = this._cells.map(function(a) {
              return a.close();
            });
            if (callback)
              Pledge.all(closed).then(function() {
                callback.call(context);
              });
          };
          Pipeline.prototype._loop = function(direction, start, end, step, message, callback, context) {
            var cells = this._cells, n = cells.length, self2 = this;
            while (n--) cells[n].pending(direction);
            var pipe = function(index, error, msg) {
              if (index === end) return callback.call(context, error, msg);
              cells[index][direction](error, msg, function(err, m2) {
                if (err) self2._stopped[direction] = true;
                pipe(index + step, err, m2);
              });
            };
            pipe(start, null, message);
          };
          module2.exports = Pipeline;
        },
        /***/
        521(module2, __unused_webpack_exports, __webpack_require__2) {
          var RingBuffer = __webpack_require__2(411);
          var Pledge = function() {
            this._complete = false;
            this._callbacks = new RingBuffer(Pledge.QUEUE_SIZE);
          };
          Pledge.QUEUE_SIZE = 4;
          Pledge.all = function(list) {
            var pledge = new Pledge(), pending = list.length, n = pending;
            if (pending === 0) pledge.done();
            while (n--) list[n].then(function() {
              pending -= 1;
              if (pending === 0) pledge.done();
            });
            return pledge;
          };
          Pledge.prototype.then = function(callback) {
            if (this._complete) callback();
            else this._callbacks.push(callback);
          };
          Pledge.prototype.done = function() {
            this._complete = true;
            var callbacks = this._callbacks, callback;
            while (callback = callbacks.shift()) callback();
          };
          module2.exports = Pledge;
        },
        /***/
        411(module2) {
          var RingBuffer = function(bufferSize) {
            this._bufferSize = bufferSize;
            this.clear();
          };
          RingBuffer.prototype.clear = function() {
            this._buffer = new Array(this._bufferSize);
            this._ringOffset = 0;
            this._ringSize = this._bufferSize;
            this._head = 0;
            this._tail = 0;
            this.length = 0;
          };
          RingBuffer.prototype.push = function(value) {
            var expandBuffer = false, expandRing = false;
            if (this._ringSize < this._bufferSize) {
              expandBuffer = this._tail === 0;
            } else if (this._ringOffset === this._ringSize) {
              expandBuffer = true;
              expandRing = this._tail === 0;
            }
            if (expandBuffer) {
              this._tail = this._bufferSize;
              this._buffer = this._buffer.concat(new Array(this._bufferSize));
              this._bufferSize = this._buffer.length;
              if (expandRing)
                this._ringSize = this._bufferSize;
            }
            this._buffer[this._tail] = value;
            this.length += 1;
            if (this._tail < this._ringSize) this._ringOffset += 1;
            this._tail = (this._tail + 1) % this._bufferSize;
          };
          RingBuffer.prototype.peek = function() {
            if (this.length === 0) return void 0;
            return this._buffer[this._head];
          };
          RingBuffer.prototype.shift = function() {
            if (this.length === 0) return void 0;
            var value = this._buffer[this._head];
            this._buffer[this._head] = void 0;
            this.length -= 1;
            this._ringOffset -= 1;
            if (this._ringOffset === 0 && this.length > 0) {
              this._head = this._ringSize;
              this._ringOffset = this.length;
              this._ringSize = this._bufferSize;
            } else {
              this._head = (this._head + 1) % this._ringSize;
            }
            return value;
          };
          module2.exports = RingBuffer;
        },
        /***/
        769(module2, __unused_webpack_exports, __webpack_require__2) {
          var Parser = __webpack_require__2(80), Pipeline = __webpack_require__2(862);
          var Extensions = function() {
            this._rsv1 = this._rsv2 = this._rsv3 = null;
            this._byName = {};
            this._inOrder = [];
            this._sessions = [];
            this._index = {};
          };
          Extensions.MESSAGE_OPCODES = [1, 2];
          var instance = {
            add: function(ext) {
              if (typeof ext.name !== "string") throw new TypeError("extension.name must be a string");
              if (ext.type !== "permessage") throw new TypeError('extension.type must be "permessage"');
              if (typeof ext.rsv1 !== "boolean") throw new TypeError("extension.rsv1 must be true or false");
              if (typeof ext.rsv2 !== "boolean") throw new TypeError("extension.rsv2 must be true or false");
              if (typeof ext.rsv3 !== "boolean") throw new TypeError("extension.rsv3 must be true or false");
              if (this._byName.hasOwnProperty(ext.name))
                throw new TypeError('An extension with name "' + ext.name + '" is already registered');
              this._byName[ext.name] = ext;
              this._inOrder.push(ext);
            },
            generateOffer: function() {
              var sessions = [], offer = [], index = {};
              this._inOrder.forEach(function(ext) {
                var session = ext.createClientSession();
                if (!session) return;
                var record = [ext, session];
                sessions.push(record);
                index[ext.name] = record;
                var offers = session.generateOffer();
                offers = offers ? [].concat(offers) : [];
                offers.forEach(function(off) {
                  offer.push(Parser.serializeParams(ext.name, off));
                }, this);
              }, this);
              this._sessions = sessions;
              this._index = index;
              return offer.length > 0 ? offer.join(", ") : null;
            },
            activate: function(header) {
              var responses = Parser.parseHeader(header), sessions = [];
              responses.eachOffer(function(name, params) {
                var record = this._index[name];
                if (!record)
                  throw new Error('Server sent an extension response for unknown extension "' + name + '"');
                var ext = record[0], session = record[1], reserved = this._reserved(ext);
                if (reserved)
                  throw new Error("Server sent two extension responses that use the RSV" + reserved[0] + ' bit: "' + reserved[1] + '" and "' + ext.name + '"');
                if (session.activate(params) !== true)
                  throw new Error("Server sent unacceptable extension parameters: " + Parser.serializeParams(name, params));
                this._reserve(ext);
                sessions.push(record);
              }, this);
              this._sessions = sessions;
              this._pipeline = new Pipeline(sessions);
            },
            generateResponse: function(header) {
              var sessions = [], response = [], offers = Parser.parseHeader(header);
              this._inOrder.forEach(function(ext) {
                var offer = offers.byName(ext.name);
                if (offer.length === 0 || this._reserved(ext)) return;
                var session = ext.createServerSession(offer);
                if (!session) return;
                this._reserve(ext);
                sessions.push([ext, session]);
                response.push(Parser.serializeParams(ext.name, session.generateResponse()));
              }, this);
              this._sessions = sessions;
              this._pipeline = new Pipeline(sessions);
              return response.length > 0 ? response.join(", ") : null;
            },
            validFrameRsv: function(frame) {
              var allowed = { rsv1: false, rsv2: false, rsv3: false }, ext;
              if (Extensions.MESSAGE_OPCODES.indexOf(frame.opcode) >= 0) {
                for (var i = 0, n = this._sessions.length; i < n; i++) {
                  ext = this._sessions[i][0];
                  allowed.rsv1 = allowed.rsv1 || ext.rsv1;
                  allowed.rsv2 = allowed.rsv2 || ext.rsv2;
                  allowed.rsv3 = allowed.rsv3 || ext.rsv3;
                }
              }
              return (allowed.rsv1 || !frame.rsv1) && (allowed.rsv2 || !frame.rsv2) && (allowed.rsv3 || !frame.rsv3);
            },
            processIncomingMessage: function(message, callback, context) {
              this._pipeline.processIncomingMessage(message, callback, context);
            },
            processOutgoingMessage: function(message, callback, context) {
              this._pipeline.processOutgoingMessage(message, callback, context);
            },
            close: function(callback, context) {
              if (!this._pipeline) return callback.call(context);
              this._pipeline.close(callback, context);
            },
            _reserve: function(ext) {
              this._rsv1 = this._rsv1 || ext.rsv1 && ext.name;
              this._rsv2 = this._rsv2 || ext.rsv2 && ext.name;
              this._rsv3 = this._rsv3 || ext.rsv3 && ext.name;
            },
            _reserved: function(ext) {
              if (this._rsv1 && ext.rsv1) return [1, this._rsv1];
              if (this._rsv2 && ext.rsv2) return [2, this._rsv2];
              if (this._rsv3 && ext.rsv3) return [3, this._rsv3];
              return false;
            }
          };
          for (var key in instance)
            Extensions.prototype[key] = instance[key];
          module2.exports = Extensions;
        },
        /***/
        407(__unused_webpack_module, exports$1, __webpack_require__2) {
          var Url = __webpack_require__2(16);
          var spawn = __webpack_require__2(317).spawn;
          var fs = __webpack_require__2(896);
          exports$1.z = function() {
            var self2 = this;
            var http = __webpack_require__2(611);
            var https = __webpack_require__2(692);
            var request;
            var response;
            var settings = {};
            var disableHeaderCheck = false;
            var defaultHeaders = {
              "User-Agent": "node-XMLHttpRequest",
              "Accept": "*/*"
            };
            var headers = {};
            var headersCase = {};
            var forbiddenRequestHeaders = [
              "accept-charset",
              "accept-encoding",
              "access-control-request-headers",
              "access-control-request-method",
              "connection",
              "content-length",
              "content-transfer-encoding",
              "cookie",
              "cookie2",
              "date",
              "expect",
              "host",
              "keep-alive",
              "origin",
              "referer",
              "te",
              "trailer",
              "transfer-encoding",
              "upgrade",
              "via"
            ];
            var forbiddenRequestMethods = [
              "TRACE",
              "TRACK",
              "CONNECT"
            ];
            var sendFlag = false;
            var errorFlag = false;
            var listeners = {};
            this.UNSENT = 0;
            this.OPENED = 1;
            this.HEADERS_RECEIVED = 2;
            this.LOADING = 3;
            this.DONE = 4;
            this.readyState = this.UNSENT;
            this.onreadystatechange = null;
            this.responseText = "";
            this.responseXML = "";
            this.status = null;
            this.statusText = null;
            this.withCredentials = false;
            var isAllowedHttpHeader = function(header) {
              return disableHeaderCheck || header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1;
            };
            var isAllowedHttpMethod = function(method) {
              return method && forbiddenRequestMethods.indexOf(method) === -1;
            };
            this.open = function(method, url, async, user, password) {
              this.abort();
              errorFlag = false;
              if (!isAllowedHttpMethod(method)) {
                throw new Error("SecurityError: Request method not allowed");
              }
              settings = {
                "method": method,
                "url": url.toString(),
                "async": typeof async !== "boolean" ? true : async,
                "user": user || null,
                "password": password || null
              };
              setState(this.OPENED);
            };
            this.setDisableHeaderCheck = function(state) {
              disableHeaderCheck = state;
            };
            this.setRequestHeader = function(header, value) {
              if (this.readyState !== this.OPENED) {
                throw new Error("INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN");
              }
              if (!isAllowedHttpHeader(header)) {
                console.warn('Refused to set unsafe header "' + header + '"');
                return;
              }
              if (sendFlag) {
                throw new Error("INVALID_STATE_ERR: send flag is true");
              }
              header = headersCase[header.toLowerCase()] || header;
              headersCase[header.toLowerCase()] = header;
              headers[header] = headers[header] ? headers[header] + ", " + value : value;
            };
            this.getResponseHeader = function(header) {
              if (typeof header === "string" && this.readyState > this.OPENED && response && response.headers && response.headers[header.toLowerCase()] && !errorFlag) {
                return response.headers[header.toLowerCase()];
              }
              return null;
            };
            this.getAllResponseHeaders = function() {
              if (this.readyState < this.HEADERS_RECEIVED || errorFlag) {
                return "";
              }
              var result = "";
              for (var i in response.headers) {
                if (i !== "set-cookie" && i !== "set-cookie2") {
                  result += i + ": " + response.headers[i] + "\r\n";
                }
              }
              return result.substr(0, result.length - 2);
            };
            this.getRequestHeader = function(name) {
              if (typeof name === "string" && headersCase[name.toLowerCase()]) {
                return headers[headersCase[name.toLowerCase()]];
              }
              return "";
            };
            this.send = function(data) {
              if (this.readyState !== this.OPENED) {
                throw new Error("INVALID_STATE_ERR: connection must be opened before send() is called");
              }
              if (sendFlag) {
                throw new Error("INVALID_STATE_ERR: send has already been called");
              }
              var ssl = false, local = false;
              var url = Url.parse(settings.url);
              var host;
              switch (url.protocol) {
                case "https:":
                  ssl = true;
                // SSL & non-SSL both need host, no break here.
                case "http:":
                  host = url.hostname;
                  break;
                case "file:":
                  local = true;
                  break;
                case void 0:
                case null:
                case "":
                  host = "localhost";
                  break;
                default:
                  throw new Error("Protocol not supported.");
              }
              if (local) {
                if (settings.method !== "GET") {
                  throw new Error("XMLHttpRequest: Only GET method is supported");
                }
                if (settings.async) {
                  fs.readFile(url.pathname, "utf8", function(error, data2) {
                    if (error) {
                      self2.handleError(error);
                    } else {
                      self2.status = 200;
                      self2.responseText = data2;
                      setState(self2.DONE);
                    }
                  });
                } else {
                  try {
                    this.responseText = fs.readFileSync(url.pathname, "utf8");
                    this.status = 200;
                    setState(self2.DONE);
                  } catch (e) {
                    this.handleError(e);
                  }
                }
                return;
              }
              var port = url.port || (ssl ? 443 : 80);
              var uri = url.pathname + (url.search ? url.search : "");
              for (var name in defaultHeaders) {
                if (!headersCase[name.toLowerCase()]) {
                  headers[name] = defaultHeaders[name];
                }
              }
              headers.Host = host;
              if (!(ssl && port === 443 || port === 80)) {
                headers.Host += ":" + url.port;
              }
              if (settings.user) {
                if (typeof settings.password === "undefined") {
                  settings.password = "";
                }
                var authBuf = new Buffer(settings.user + ":" + settings.password);
                headers.Authorization = "Basic " + authBuf.toString("base64");
              }
              if (settings.method === "GET" || settings.method === "HEAD") {
                data = null;
              } else if (data) {
                headers["Content-Length"] = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
                if (!headers["Content-Type"]) {
                  headers["Content-Type"] = "text/plain;charset=UTF-8";
                }
              } else if (settings.method === "POST") {
                headers["Content-Length"] = 0;
              }
              var options = {
                host,
                port,
                path: uri,
                method: settings.method,
                headers,
                agent: false,
                withCredentials: self2.withCredentials
              };
              errorFlag = false;
              if (settings.async) {
                var doRequest = ssl ? https.request : http.request;
                sendFlag = true;
                self2.dispatchEvent("readystatechange");
                var responseHandler = function responseHandler2(resp2) {
                  response = resp2;
                  if (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 303 || response.statusCode === 307) {
                    settings.url = response.headers.location;
                    var url2 = Url.parse(settings.url);
                    host = url2.hostname;
                    var newOptions = {
                      hostname: url2.hostname,
                      port: url2.port,
                      path: url2.path,
                      method: response.statusCode === 303 ? "GET" : settings.method,
                      headers,
                      withCredentials: self2.withCredentials
                    };
                    request = doRequest(newOptions, responseHandler2).on("error", errorHandler);
                    request.end();
                    return;
                  }
                  response.setEncoding("utf8");
                  setState(self2.HEADERS_RECEIVED);
                  self2.status = response.statusCode;
                  response.on("data", function(chunk) {
                    if (chunk) {
                      self2.responseText += chunk;
                    }
                    if (sendFlag) {
                      setState(self2.LOADING);
                    }
                  });
                  response.on("end", function() {
                    if (sendFlag) {
                      setState(self2.DONE);
                      sendFlag = false;
                    }
                  });
                  response.on("error", function(error) {
                    self2.handleError(error);
                  });
                };
                var errorHandler = function errorHandler2(error) {
                  self2.handleError(error);
                };
                request = doRequest(options, responseHandler).on("error", errorHandler);
                if (data) {
                  request.write(data);
                }
                request.end();
                self2.dispatchEvent("loadstart");
              } else {
                var contentFile = ".node-xmlhttprequest-content-" + process.pid;
                var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
                fs.writeFileSync(syncFile, "", "utf8");
                var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var req = doRequest(options, function(response) {response.setEncoding('utf8');response.on('data', function(chunk) {  responseText += chunk;});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: error}), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: error}), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
                var syncProc = spawn(process.argv[0], ["-e", execString]);
                while (fs.existsSync(syncFile)) {
                }
                var resp = JSON.parse(fs.readFileSync(contentFile, "utf8"));
                syncProc.stdin.end();
                fs.unlinkSync(contentFile);
                if (resp.err) {
                  self2.handleError(resp.err);
                } else {
                  response = resp.data;
                  self2.status = resp.data.statusCode;
                  self2.responseText = resp.data.text;
                  setState(self2.DONE);
                }
              }
            };
            this.handleError = function(error) {
              this.status = 0;
              this.statusText = error;
              this.responseText = error.stack;
              errorFlag = true;
              setState(this.DONE);
              this.dispatchEvent("error");
            };
            this.abort = function() {
              if (request) {
                request.abort();
                request = null;
              }
              headers = defaultHeaders;
              this.status = 0;
              this.responseText = "";
              this.responseXML = "";
              errorFlag = true;
              if (this.readyState !== this.UNSENT && (this.readyState !== this.OPENED || sendFlag) && this.readyState !== this.DONE) {
                sendFlag = false;
                setState(this.DONE);
              }
              this.readyState = this.UNSENT;
              this.dispatchEvent("abort");
            };
            this.addEventListener = function(event, callback) {
              if (!(event in listeners)) {
                listeners[event] = [];
              }
              listeners[event].push(callback);
            };
            this.removeEventListener = function(event, callback) {
              if (event in listeners) {
                listeners[event] = listeners[event].filter(function(ev) {
                  return ev !== callback;
                });
              }
            };
            this.dispatchEvent = function(event) {
              if (typeof self2["on" + event] === "function") {
                self2["on" + event]();
              }
              if (event in listeners) {
                for (var i = 0, len = listeners[event].length; i < len; i++) {
                  listeners[event][i].call(self2);
                }
              }
            };
            var setState = function(state) {
              if (state == self2.LOADING || self2.readyState !== state) {
                self2.readyState = state;
                if (settings.async || self2.readyState < self2.OPENED || self2.readyState === self2.DONE) {
                  self2.dispatchEvent("readystatechange");
                }
                if (self2.readyState === self2.DONE && !errorFlag) {
                  self2.dispatchEvent("load");
                  self2.dispatchEvent("loadend");
                }
              }
            };
          };
        },
        /***/
        42(module2, __unused_webpack_exports, __webpack_require__2) {
          module2.exports = __webpack_require__2(368)["default"];
        },
        /***/
        368(__unused_webpack_module, __webpack_exports__2, __webpack_require__2) {
          __webpack_require__2.d(__webpack_exports__2, {
            "default": () => (
              /* binding */
              PusherWithEncryption
            )
          });
          function encode(s) {
            return btoa(utob(s));
          }
          var fromCharCode = String.fromCharCode;
          var b64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
          var cb_utob = function(c2) {
            var cc = c2.charCodeAt(0);
            return cc < 128 ? c2 : cc < 2048 ? fromCharCode(192 | cc >>> 6) + fromCharCode(128 | cc & 63) : fromCharCode(224 | cc >>> 12 & 15) + fromCharCode(128 | cc >>> 6 & 63) + fromCharCode(128 | cc & 63);
          };
          var utob = function(u2) {
            return u2.replace(/[^\x00-\x7F]/g, cb_utob);
          };
          var cb_encode = function(ccc) {
            var padlen = [0, 2, 1][ccc.length % 3];
            var ord = ccc.charCodeAt(0) << 16 | (ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8 | (ccc.length > 2 ? ccc.charCodeAt(2) : 0);
            var chars = [
              b64chars.charAt(ord >>> 18),
              b64chars.charAt(ord >>> 12 & 63),
              padlen >= 2 ? "=" : b64chars.charAt(ord >>> 6 & 63),
              padlen >= 1 ? "=" : b64chars.charAt(ord & 63)
            ];
            return chars.join("");
          };
          var btoa = commonjsGlobal.btoa || function(b2) {
            return b2.replace(/[\s\S]{1,3}/g, cb_encode);
          };
          class Timer {
            constructor(set, clear, delay, callback) {
              this.clear = clear;
              this.timer = set(() => {
                if (this.timer) {
                  this.timer = callback(this.timer);
                }
              }, delay);
            }
            isRunning() {
              return this.timer !== null;
            }
            ensureAborted() {
              if (this.timer) {
                this.clear(this.timer);
                this.timer = null;
              }
            }
          }
          const abstract_timer = Timer;
          function timers_clearTimeout(timer) {
            commonjsGlobal.clearTimeout(timer);
          }
          function timers_clearInterval(timer) {
            commonjsGlobal.clearInterval(timer);
          }
          class OneOffTimer extends abstract_timer {
            constructor(delay, callback) {
              super(setTimeout, timers_clearTimeout, delay, function(timer) {
                callback();
                return null;
              });
            }
          }
          class PeriodicTimer extends abstract_timer {
            constructor(delay, callback) {
              super(setInterval, timers_clearInterval, delay, function(timer) {
                callback();
                return timer;
              });
            }
          }
          var Util = {
            now() {
              if (Date.now) {
                return Date.now();
              } else {
                return (/* @__PURE__ */ new Date()).valueOf();
              }
            },
            defer(callback) {
              return new OneOffTimer(0, callback);
            },
            method(name, ...args) {
              var boundArguments = Array.prototype.slice.call(arguments, 1);
              return function(object) {
                return object[name].apply(object, boundArguments.concat(arguments));
              };
            }
          };
          const util = Util;
          function extend(target, ...sources) {
            for (var i = 0; i < sources.length; i++) {
              var extensions = sources[i];
              for (var property in extensions) {
                if (extensions[property] && extensions[property].constructor && extensions[property].constructor === Object) {
                  target[property] = extend(target[property] || {}, extensions[property]);
                } else {
                  target[property] = extensions[property];
                }
              }
            }
            return target;
          }
          function stringify() {
            var m2 = ["Pusher"];
            for (var i = 0; i < arguments.length; i++) {
              if (typeof arguments[i] === "string") {
                m2.push(arguments[i]);
              } else {
                m2.push(safeJSONStringify(arguments[i]));
              }
            }
            return m2.join(" : ");
          }
          function arrayIndexOf(array, item) {
            var nativeIndexOf = Array.prototype.indexOf;
            if (array === null) {
              return -1;
            }
            if (nativeIndexOf && array.indexOf === nativeIndexOf) {
              return array.indexOf(item);
            }
            for (var i = 0, l2 = array.length; i < l2; i++) {
              if (array[i] === item) {
                return i;
              }
            }
            return -1;
          }
          function objectApply(object, f2) {
            for (var key in object) {
              if (Object.prototype.hasOwnProperty.call(object, key)) {
                f2(object[key], key, object);
              }
            }
          }
          function keys(object) {
            var keys2 = [];
            objectApply(object, function(_2, key) {
              keys2.push(key);
            });
            return keys2;
          }
          function values(object) {
            var values2 = [];
            objectApply(object, function(value) {
              values2.push(value);
            });
            return values2;
          }
          function apply(array, f2, context) {
            for (var i = 0; i < array.length; i++) {
              f2.call(context || commonjsGlobal, array[i], i, array);
            }
          }
          function map(array, f2) {
            var result = [];
            for (var i = 0; i < array.length; i++) {
              result.push(f2(array[i], i, array, result));
            }
            return result;
          }
          function mapObject(object, f2) {
            var result = {};
            objectApply(object, function(value, key) {
              result[key] = f2(value);
            });
            return result;
          }
          function filter(array, test) {
            test = test || function(value) {
              return !!value;
            };
            var result = [];
            for (var i = 0; i < array.length; i++) {
              if (test(array[i], i, array, result)) {
                result.push(array[i]);
              }
            }
            return result;
          }
          function filterObject(object, test) {
            var result = {};
            objectApply(object, function(value, key) {
              if (test && test(value, key, object, result) || Boolean(value)) {
                result[key] = value;
              }
            });
            return result;
          }
          function flatten(object) {
            var result = [];
            objectApply(object, function(value, key) {
              result.push([key, value]);
            });
            return result;
          }
          function any(array, test) {
            for (var i = 0; i < array.length; i++) {
              if (test(array[i], i, array)) {
                return true;
              }
            }
            return false;
          }
          function collections_all(array, test) {
            for (var i = 0; i < array.length; i++) {
              if (!test(array[i], i, array)) {
                return false;
              }
            }
            return true;
          }
          function encodeParamsObject(data) {
            return mapObject(data, function(value) {
              if (typeof value === "object") {
                value = safeJSONStringify(value);
              }
              return encodeURIComponent(encode(value.toString()));
            });
          }
          function buildQueryString(data) {
            var params = filterObject(data, function(value) {
              return value !== void 0;
            });
            var query = map(flatten(encodeParamsObject(params)), util.method("join", "=")).join("&");
            return query;
          }
          function decycleObject(object) {
            var objects = [], paths = [];
            return (function derez(value, path) {
              var i, name, nu;
              switch (typeof value) {
                case "object":
                  if (!value) {
                    return null;
                  }
                  for (i = 0; i < objects.length; i += 1) {
                    if (objects[i] === value) {
                      return { $ref: paths[i] };
                    }
                  }
                  objects.push(value);
                  paths.push(path);
                  if (Object.prototype.toString.apply(value) === "[object Array]") {
                    nu = [];
                    for (i = 0; i < value.length; i += 1) {
                      nu[i] = derez(value[i], path + "[" + i + "]");
                    }
                  } else {
                    nu = {};
                    for (name in value) {
                      if (Object.prototype.hasOwnProperty.call(value, name)) {
                        nu[name] = derez(value[name], path + "[" + JSON.stringify(name) + "]");
                      }
                    }
                  }
                  return nu;
                case "number":
                case "string":
                case "boolean":
                  return value;
              }
            })(object, "$");
          }
          function safeJSONStringify(source) {
            try {
              return JSON.stringify(source);
            } catch (e) {
              return JSON.stringify(decycleObject(source));
            }
          }
          var Defaults = {
            VERSION: "8.5.0",
            PROTOCOL: 7,
            wsPort: 80,
            wssPort: 443,
            wsPath: "",
            httpHost: "sockjs.pusher.com",
            httpPort: 80,
            httpsPort: 443,
            httpPath: "/pusher",
            stats_host: "stats.pusher.com",
            authEndpoint: "/pusher/auth",
            authTransport: "ajax",
            activityTimeout: 12e4,
            pongTimeout: 3e4,
            unavailableTimeout: 1e4,
            userAuthentication: {
              endpoint: "/pusher/user-auth",
              transport: "ajax"
            },
            channelAuthorization: {
              endpoint: "/pusher/auth",
              transport: "ajax"
            }
          };
          const defaults = Defaults;
          function getGenericURL(baseScheme, params, path) {
            var scheme = baseScheme + (params.useTLS ? "s" : "");
            var host = params.useTLS ? params.hostTLS : params.hostNonTLS;
            return scheme + "://" + host + path;
          }
          function getGenericPath(key, queryString) {
            var path = "/app/" + key;
            var query = "?protocol=" + defaults.PROTOCOL + "&client=js&version=" + defaults.VERSION + (queryString ? "&" + queryString : "");
            return path + query;
          }
          var ws = {
            getInitial: function(key, params) {
              var path = (params.httpPath || "") + getGenericPath(key, "flash=false");
              return getGenericURL("ws", params, path);
            }
          };
          var http = {
            getInitial: function(key, params) {
              var path = (params.httpPath || "/pusher") + getGenericPath(key);
              return getGenericURL("http", params, path);
            }
          };
          class CallbackRegistry {
            constructor() {
              this._callbacks = {};
            }
            get(name) {
              return this._callbacks[prefix(name)];
            }
            add(name, callback, context) {
              var prefixedEventName = prefix(name);
              this._callbacks[prefixedEventName] = this._callbacks[prefixedEventName] || [];
              this._callbacks[prefixedEventName].push({
                fn: callback,
                context
              });
            }
            remove(name, callback, context) {
              if (!name && !callback && !context) {
                this._callbacks = {};
                return;
              }
              var names = name ? [prefix(name)] : keys(this._callbacks);
              if (callback || context) {
                this.removeCallback(names, callback, context);
              } else {
                this.removeAllCallbacks(names);
              }
            }
            removeCallback(names, callback, context) {
              apply(names, function(name) {
                this._callbacks[name] = filter(this._callbacks[name] || [], function(binding) {
                  return callback && callback !== binding.fn || context && context !== binding.context;
                });
                if (this._callbacks[name].length === 0) {
                  delete this._callbacks[name];
                }
              }, this);
            }
            removeAllCallbacks(names) {
              apply(names, function(name) {
                delete this._callbacks[name];
              }, this);
            }
          }
          function prefix(name) {
            return "_" + name;
          }
          class Dispatcher {
            constructor(failThrough) {
              this.callbacks = new CallbackRegistry();
              this.global_callbacks = [];
              this.failThrough = failThrough;
            }
            bind(eventName, callback, context) {
              this.callbacks.add(eventName, callback, context);
              return this;
            }
            bind_global(callback) {
              this.global_callbacks.push(callback);
              return this;
            }
            unbind(eventName, callback, context) {
              this.callbacks.remove(eventName, callback, context);
              return this;
            }
            unbind_global(callback) {
              if (!callback) {
                this.global_callbacks = [];
                return this;
              }
              this.global_callbacks = filter(this.global_callbacks || [], (c2) => c2 !== callback);
              return this;
            }
            unbind_all() {
              this.unbind();
              this.unbind_global();
              return this;
            }
            emit(eventName, data, metadata) {
              for (var i = 0; i < this.global_callbacks.length; i++) {
                this.global_callbacks[i](eventName, data);
              }
              var callbacks = this.callbacks.get(eventName);
              var args = [];
              if (metadata) {
                args.push(data, metadata);
              } else if (data) {
                args.push(data);
              }
              if (callbacks && callbacks.length > 0) {
                for (var i = 0; i < callbacks.length; i++) {
                  callbacks[i].fn.apply(callbacks[i].context || commonjsGlobal, args);
                }
              } else if (this.failThrough) {
                this.failThrough(eventName, data);
              }
              return this;
            }
          }
          class Logger {
            constructor() {
              this.globalLog = (message) => {
                if (commonjsGlobal.console && commonjsGlobal.console.log) {
                  commonjsGlobal.console.log(message);
                }
              };
            }
            debug(...args) {
              this.log(this.globalLog, args);
            }
            warn(...args) {
              this.log(this.globalLogWarn, args);
            }
            error(...args) {
              this.log(this.globalLogError, args);
            }
            globalLogWarn(message) {
              if (commonjsGlobal.console && commonjsGlobal.console.warn) {
                commonjsGlobal.console.warn(message);
              } else {
                this.globalLog(message);
              }
            }
            globalLogError(message) {
              if (commonjsGlobal.console && commonjsGlobal.console.error) {
                commonjsGlobal.console.error(message);
              } else {
                this.globalLogWarn(message);
              }
            }
            log(defaultLoggingFunction, ...args) {
              var message = stringify.apply(this, arguments);
              if (pusher2.log) {
                pusher2.log(message);
              } else if (pusher2.logToConsole) {
                const log = defaultLoggingFunction.bind(this);
                log(message);
              }
            }
          }
          const logger = new Logger();
          class TransportConnection extends Dispatcher {
            constructor(hooks2, name, priority, key, options) {
              super();
              this.initialize = node_runtime.transportConnectionInitializer;
              this.hooks = hooks2;
              this.name = name;
              this.priority = priority;
              this.key = key;
              this.options = options;
              this.state = "new";
              this.timeline = options.timeline;
              this.activityTimeout = options.activityTimeout;
              this.id = this.timeline.generateUniqueID();
            }
            handlesActivityChecks() {
              return Boolean(this.hooks.handlesActivityChecks);
            }
            supportsPing() {
              return Boolean(this.hooks.supportsPing);
            }
            connect() {
              if (this.socket || this.state !== "initialized") {
                return false;
              }
              var url = this.hooks.urls.getInitial(this.key, this.options);
              try {
                this.socket = this.hooks.getSocket(url, this.options);
              } catch (e) {
                util.defer(() => {
                  this.onError(e);
                  this.changeState("closed");
                });
                return false;
              }
              this.bindListeners();
              logger.debug("Connecting", { transport: this.name, url });
              this.changeState("connecting");
              return true;
            }
            close() {
              if (this.socket) {
                this.socket.close();
                return true;
              } else {
                return false;
              }
            }
            send(data) {
              if (this.state === "open") {
                util.defer(() => {
                  if (this.socket) {
                    this.socket.send(data);
                  }
                });
                return true;
              } else {
                return false;
              }
            }
            ping() {
              if (this.state === "open" && this.supportsPing()) {
                this.socket.ping();
              }
            }
            onOpen() {
              if (this.hooks.beforeOpen) {
                this.hooks.beforeOpen(this.socket, this.hooks.urls.getPath(this.key, this.options));
              }
              this.changeState("open");
              this.socket.onopen = void 0;
            }
            onError(error) {
              this.emit("error", { type: "WebSocketError", error });
              this.timeline.error(this.buildTimelineMessage({ error: error.toString() }));
            }
            onClose(closeEvent) {
              if (closeEvent) {
                this.changeState("closed", {
                  code: closeEvent.code,
                  reason: closeEvent.reason,
                  wasClean: closeEvent.wasClean
                });
              } else {
                this.changeState("closed");
              }
              this.unbindListeners();
              this.socket = void 0;
            }
            onMessage(message) {
              this.emit("message", message);
            }
            onActivity() {
              this.emit("activity");
            }
            bindListeners() {
              this.socket.onopen = () => {
                this.onOpen();
              };
              this.socket.onerror = (error) => {
                this.onError(error);
              };
              this.socket.onclose = (closeEvent) => {
                this.onClose(closeEvent);
              };
              this.socket.onmessage = (message) => {
                this.onMessage(message);
              };
              if (this.supportsPing()) {
                this.socket.onactivity = () => {
                  this.onActivity();
                };
              }
            }
            unbindListeners() {
              if (this.socket) {
                this.socket.onopen = void 0;
                this.socket.onerror = void 0;
                this.socket.onclose = void 0;
                this.socket.onmessage = void 0;
                if (this.supportsPing()) {
                  this.socket.onactivity = void 0;
                }
              }
            }
            changeState(state2, params) {
              this.state = state2;
              this.timeline.info(this.buildTimelineMessage({
                state: state2,
                params
              }));
              this.emit(state2, params);
            }
            buildTimelineMessage(message) {
              return extend({ cid: this.id }, message);
            }
          }
          class Transport {
            constructor(hooks2) {
              this.hooks = hooks2;
            }
            isSupported(environment) {
              return this.hooks.isSupported(environment);
            }
            createConnection(name, priority, key, options) {
              return new TransportConnection(this.hooks, name, priority, key, options);
            }
          }
          var WSTransport = new Transport({
            urls: ws,
            handlesActivityChecks: false,
            supportsPing: false,
            isInitialized: function() {
              return Boolean(node_runtime.getWebSocketAPI());
            },
            isSupported: function() {
              return Boolean(node_runtime.getWebSocketAPI());
            },
            getSocket: function(url) {
              return node_runtime.createWebSocket(url);
            }
          });
          var httpConfiguration = {
            urls: http,
            handlesActivityChecks: false,
            supportsPing: true,
            isInitialized: function() {
              return true;
            }
          };
          var streamingConfiguration = extend({
            getSocket: function(url) {
              return node_runtime.HTTPFactory.createStreamingSocket(url);
            }
          }, httpConfiguration);
          var pollingConfiguration = extend({
            getSocket: function(url) {
              return node_runtime.HTTPFactory.createPollingSocket(url);
            }
          }, httpConfiguration);
          var xhrConfiguration = {
            isSupported: function() {
              return node_runtime.isXHRSupported();
            }
          };
          var XHRStreamingTransport = new Transport(extend({}, streamingConfiguration, xhrConfiguration));
          var XHRPollingTransport = new Transport(extend({}, pollingConfiguration, xhrConfiguration));
          var Transports = {
            ws: WSTransport,
            xhr_streaming: XHRStreamingTransport,
            xhr_polling: XHRPollingTransport
          };
          const transports = Transports;
          class AssistantToTheTransportManager {
            constructor(manager, transport, options) {
              this.manager = manager;
              this.transport = transport;
              this.minPingDelay = options.minPingDelay;
              this.maxPingDelay = options.maxPingDelay;
              this.pingDelay = void 0;
            }
            createConnection(name, priority, key, options) {
              options = extend({}, options, {
                activityTimeout: this.pingDelay
              });
              var connection = this.transport.createConnection(name, priority, key, options);
              var openTimestamp = null;
              var onOpen = function() {
                connection.unbind("open", onOpen);
                connection.bind("closed", onClosed);
                openTimestamp = util.now();
              };
              var onClosed = (closeEvent) => {
                connection.unbind("closed", onClosed);
                if (closeEvent.code === 1002 || closeEvent.code === 1003) {
                  this.manager.reportDeath();
                } else if (!closeEvent.wasClean && openTimestamp) {
                  var lifespan = util.now() - openTimestamp;
                  if (lifespan < 2 * this.maxPingDelay) {
                    this.manager.reportDeath();
                    this.pingDelay = Math.max(lifespan / 2, this.minPingDelay);
                  }
                }
              };
              connection.bind("open", onOpen);
              return connection;
            }
            isSupported(environment) {
              return this.manager.isAlive() && this.transport.isSupported(environment);
            }
          }
          const Protocol = {
            decodeMessage: function(messageEvent) {
              try {
                var messageData = JSON.parse(messageEvent.data);
                var pusherEventData = messageData.data;
                if (typeof pusherEventData === "string") {
                  try {
                    pusherEventData = JSON.parse(messageData.data);
                  } catch (e) {
                  }
                }
                var pusherEvent = {
                  event: messageData.event,
                  channel: messageData.channel,
                  data: pusherEventData
                };
                if (messageData.user_id) {
                  pusherEvent.user_id = messageData.user_id;
                }
                return pusherEvent;
              } catch (e) {
                throw { type: "MessageParseError", error: e, data: messageEvent.data };
              }
            },
            encodeMessage: function(event) {
              return JSON.stringify(event);
            },
            processHandshake: function(messageEvent) {
              var message = Protocol.decodeMessage(messageEvent);
              if (message.event === "pusher:connection_established") {
                if (!message.data.activity_timeout) {
                  throw "No activity timeout specified in handshake";
                }
                return {
                  action: "connected",
                  id: message.data.socket_id,
                  activityTimeout: message.data.activity_timeout * 1e3
                };
              } else if (message.event === "pusher:error") {
                return {
                  action: this.getCloseAction(message.data),
                  error: this.getCloseError(message.data)
                };
              } else {
                throw "Invalid handshake";
              }
            },
            getCloseAction: function(closeEvent) {
              if (closeEvent.code < 4e3) {
                if (closeEvent.code >= 1002 && closeEvent.code <= 1004) {
                  return "backoff";
                } else {
                  return null;
                }
              } else if (closeEvent.code === 4e3) {
                return "tls_only";
              } else if (closeEvent.code < 4100) {
                return "refused";
              } else if (closeEvent.code < 4200) {
                return "backoff";
              } else if (closeEvent.code < 4300) {
                return "retry";
              } else {
                return "refused";
              }
            },
            getCloseError: function(closeEvent) {
              if (closeEvent.code !== 1e3 && closeEvent.code !== 1001) {
                return {
                  type: "PusherError",
                  data: {
                    code: closeEvent.code,
                    message: closeEvent.reason || closeEvent.message
                  }
                };
              } else {
                return null;
              }
            }
          };
          const protocol = Protocol;
          class Connection extends Dispatcher {
            constructor(id, transport) {
              super();
              this.id = id;
              this.transport = transport;
              this.activityTimeout = transport.activityTimeout;
              this.bindListeners();
            }
            handlesActivityChecks() {
              return this.transport.handlesActivityChecks();
            }
            send(data) {
              return this.transport.send(data);
            }
            send_event(name, data, channel) {
              var event = { event: name, data };
              if (channel) {
                event.channel = channel;
              }
              logger.debug("Event sent", event);
              return this.send(protocol.encodeMessage(event));
            }
            ping() {
              if (this.transport.supportsPing()) {
                this.transport.ping();
              } else {
                this.send_event("pusher:ping", {});
              }
            }
            close() {
              this.transport.close();
            }
            bindListeners() {
              var listeners = {
                message: (messageEvent) => {
                  var pusherEvent;
                  try {
                    pusherEvent = protocol.decodeMessage(messageEvent);
                  } catch (e) {
                    this.emit("error", {
                      type: "MessageParseError",
                      error: e,
                      data: messageEvent.data
                    });
                  }
                  if (pusherEvent !== void 0) {
                    logger.debug("Event recd", pusherEvent);
                    switch (pusherEvent.event) {
                      case "pusher:error":
                        this.emit("error", {
                          type: "PusherError",
                          data: pusherEvent.data
                        });
                        break;
                      case "pusher:ping":
                        this.emit("ping");
                        break;
                      case "pusher:pong":
                        this.emit("pong");
                        break;
                    }
                    this.emit("message", pusherEvent);
                  }
                },
                activity: () => {
                  this.emit("activity");
                },
                error: (error) => {
                  this.emit("error", error);
                },
                closed: (closeEvent) => {
                  unbindListeners();
                  if (closeEvent && closeEvent.code) {
                    this.handleCloseEvent(closeEvent);
                  }
                  this.transport = null;
                  this.emit("closed");
                }
              };
              var unbindListeners = () => {
                objectApply(listeners, (listener, event) => {
                  this.transport.unbind(event, listener);
                });
              };
              objectApply(listeners, (listener, event) => {
                this.transport.bind(event, listener);
              });
            }
            handleCloseEvent(closeEvent) {
              var action = protocol.getCloseAction(closeEvent);
              var error = protocol.getCloseError(closeEvent);
              if (error) {
                this.emit("error", error);
              }
              if (action) {
                this.emit(action, { action, error });
              }
            }
          }
          class Handshake {
            constructor(transport, callback) {
              this.transport = transport;
              this.callback = callback;
              this.bindListeners();
            }
            close() {
              this.unbindListeners();
              this.transport.close();
            }
            bindListeners() {
              this.onMessage = (m2) => {
                this.unbindListeners();
                var result;
                try {
                  result = protocol.processHandshake(m2);
                } catch (e) {
                  this.finish("error", { error: e });
                  this.transport.close();
                  return;
                }
                if (result.action === "connected") {
                  this.finish("connected", {
                    connection: new Connection(result.id, this.transport),
                    activityTimeout: result.activityTimeout
                  });
                } else {
                  this.finish(result.action, { error: result.error });
                  this.transport.close();
                }
              };
              this.onClosed = (closeEvent) => {
                this.unbindListeners();
                var action = protocol.getCloseAction(closeEvent) || "backoff";
                var error = protocol.getCloseError(closeEvent);
                this.finish(action, { error });
              };
              this.transport.bind("message", this.onMessage);
              this.transport.bind("closed", this.onClosed);
            }
            unbindListeners() {
              this.transport.unbind("message", this.onMessage);
              this.transport.unbind("closed", this.onClosed);
            }
            finish(action, params) {
              this.callback(extend({ transport: this.transport, action }, params));
            }
          }
          class TimelineSender {
            constructor(timeline, options) {
              this.timeline = timeline;
              this.options = options || {};
            }
            send(useTLS, callback) {
              if (this.timeline.isEmpty()) {
                return;
              }
              this.timeline.send(node_runtime.TimelineTransport.getAgent(this, useTLS), callback);
            }
          }
          class BadEventName extends Error {
            constructor(msg) {
              super(msg);
              Object.setPrototypeOf(this, new.target.prototype);
            }
          }
          class BadChannelName extends Error {
            constructor(msg) {
              super(msg);
              Object.setPrototypeOf(this, new.target.prototype);
            }
          }
          class TransportPriorityTooLow extends Error {
            constructor(msg) {
              super(msg);
              Object.setPrototypeOf(this, new.target.prototype);
            }
          }
          class TransportClosed extends Error {
            constructor(msg) {
              super(msg);
              Object.setPrototypeOf(this, new.target.prototype);
            }
          }
          class UnsupportedFeature extends Error {
            constructor(msg) {
              super(msg);
              Object.setPrototypeOf(this, new.target.prototype);
            }
          }
          class UnsupportedTransport extends Error {
            constructor(msg) {
              super(msg);
              Object.setPrototypeOf(this, new.target.prototype);
            }
          }
          class UnsupportedStrategy extends Error {
            constructor(msg) {
              super(msg);
              Object.setPrototypeOf(this, new.target.prototype);
            }
          }
          class HTTPAuthError extends Error {
            constructor(status, msg) {
              super(msg);
              this.status = status;
              Object.setPrototypeOf(this, new.target.prototype);
            }
          }
          const urlStore = {
            baseUrl: "https://pusher.com",
            urls: {
              authenticationEndpoint: {
                path: "/docs/channels/server_api/authenticating_users"
              },
              authorizationEndpoint: {
                path: "/docs/channels/server_api/authorizing-users/"
              },
              javascriptQuickStart: {
                path: "/docs/javascript_quick_start"
              },
              triggeringClientEvents: {
                path: "/docs/client_api_guide/client_events#trigger-events"
              },
              encryptedChannelSupport: {
                fullUrl: "https://github.com/pusher/pusher-js/tree/cc491015371a4bde5743d1c87a0fbac0feb53195#encrypted-channel-support"
              }
            }
          };
          const buildLogSuffix = function(key) {
            const urlPrefix = "See:";
            const urlObj = urlStore.urls[key];
            if (!urlObj)
              return "";
            let url;
            if (urlObj.fullUrl) {
              url = urlObj.fullUrl;
            } else if (urlObj.path) {
              url = urlStore.baseUrl + urlObj.path;
            }
            if (!url)
              return "";
            return `${urlPrefix} ${url}`;
          };
          const url_store = { buildLogSuffix };
          class Channel extends Dispatcher {
            constructor(name, pusher3) {
              super(function(event, data) {
                logger.debug("No callbacks on " + name + " for " + event);
              });
              this.name = name;
              this.pusher = pusher3;
              this.subscribed = false;
              this.subscriptionPending = false;
              this.subscriptionCancelled = false;
            }
            authorize(socketId, callback) {
              return callback(null, { auth: "" });
            }
            trigger(event, data) {
              if (event.indexOf("client-") !== 0) {
                throw new BadEventName("Event '" + event + "' does not start with 'client-'");
              }
              if (!this.subscribed) {
                var suffix = url_store.buildLogSuffix("triggeringClientEvents");
                logger.warn(`Client event triggered before channel 'subscription_succeeded' event . ${suffix}`);
              }
              return this.pusher.send_event(event, data, this.name);
            }
            disconnect() {
              this.subscribed = false;
              this.subscriptionPending = false;
            }
            handleEvent(event) {
              var eventName = event.event;
              var data = event.data;
              if (eventName === "pusher_internal:subscription_succeeded") {
                this.handleSubscriptionSucceededEvent(event);
              } else if (eventName === "pusher_internal:subscription_count") {
                this.handleSubscriptionCountEvent(event);
              } else if (eventName.indexOf("pusher_internal:") !== 0) {
                var metadata = {};
                this.emit(eventName, data, metadata);
              }
            }
            handleSubscriptionSucceededEvent(event) {
              this.subscriptionPending = false;
              this.subscribed = true;
              if (this.subscriptionCancelled) {
                this.pusher.unsubscribe(this.name);
              } else {
                this.emit("pusher:subscription_succeeded", event.data);
              }
            }
            handleSubscriptionCountEvent(event) {
              if (event.data.subscription_count) {
                this.subscriptionCount = event.data.subscription_count;
              }
              this.emit("pusher:subscription_count", event.data);
            }
            subscribe() {
              if (this.subscribed) {
                return;
              }
              this.subscriptionPending = true;
              this.subscriptionCancelled = false;
              this.authorize(this.pusher.connection.socket_id, (error, data) => {
                if (error) {
                  this.subscriptionPending = false;
                  logger.error(error.toString());
                  this.emit("pusher:subscription_error", Object.assign({}, {
                    type: "AuthError",
                    error: error.message
                  }, error instanceof HTTPAuthError ? { status: error.status } : {}));
                } else {
                  this.pusher.send_event("pusher:subscribe", {
                    auth: data.auth,
                    channel_data: data.channel_data,
                    channel: this.name
                  });
                }
              });
            }
            unsubscribe() {
              this.subscribed = false;
              this.pusher.send_event("pusher:unsubscribe", {
                channel: this.name
              });
            }
            cancelSubscription() {
              this.subscriptionCancelled = true;
            }
            reinstateSubscription() {
              this.subscriptionCancelled = false;
            }
          }
          class PrivateChannel extends Channel {
            authorize(socketId, callback) {
              return this.pusher.config.channelAuthorizer({
                channelName: this.name,
                socketId
              }, callback);
            }
          }
          class Members {
            constructor() {
              this.reset();
            }
            get(id) {
              if (Object.prototype.hasOwnProperty.call(this.members, id)) {
                return {
                  id,
                  info: this.members[id]
                };
              } else {
                return null;
              }
            }
            each(callback) {
              objectApply(this.members, (member, id) => {
                callback(this.get(id));
              });
            }
            setMyID(id) {
              this.myID = id;
            }
            onSubscription(subscriptionData) {
              this.members = subscriptionData.presence.hash;
              this.count = subscriptionData.presence.count;
              this.me = this.get(this.myID);
            }
            addMember(memberData) {
              if (this.get(memberData.user_id) === null) {
                this.count++;
              }
              this.members[memberData.user_id] = memberData.user_info;
              return this.get(memberData.user_id);
            }
            removeMember(memberData) {
              var member = this.get(memberData.user_id);
              if (member) {
                delete this.members[memberData.user_id];
                this.count--;
              }
              return member;
            }
            reset() {
              this.members = {};
              this.count = 0;
              this.myID = null;
              this.me = null;
            }
          }
          var __awaiter = function(thisArg, _arguments, P, generator) {
            function adopt(value) {
              return value instanceof P ? value : new P(function(resolve) {
                resolve(value);
              });
            }
            return new (P || (P = Promise))(function(resolve, reject) {
              function fulfilled(value) {
                try {
                  step(generator.next(value));
                } catch (e) {
                  reject(e);
                }
              }
              function rejected(value) {
                try {
                  step(generator["throw"](value));
                } catch (e) {
                  reject(e);
                }
              }
              function step(result) {
                result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
              }
              step((generator = generator.apply(thisArg, _arguments || [])).next());
            });
          };
          class PresenceChannel extends PrivateChannel {
            constructor(name, pusher3) {
              super(name, pusher3);
              this.members = new Members();
            }
            authorize(socketId, callback) {
              super.authorize(socketId, (error, authData) => __awaiter(this, void 0, void 0, function* () {
                if (!error) {
                  authData = authData;
                  if (authData.channel_data != null) {
                    var channelData = JSON.parse(authData.channel_data);
                    this.members.setMyID(channelData.user_id);
                  } else {
                    yield this.pusher.user.signinDonePromise;
                    if (this.pusher.user.user_data != null) {
                      this.members.setMyID(this.pusher.user.user_data.id);
                    } else {
                      let suffix = url_store.buildLogSuffix("authorizationEndpoint");
                      logger.error(`Invalid auth response for channel '${this.name}', expected 'channel_data' field. ${suffix}, or the user should be signed in.`);
                      callback("Invalid auth response");
                      return;
                    }
                  }
                }
                callback(error, authData);
              }));
            }
            handleEvent(event) {
              var eventName = event.event;
              if (eventName.indexOf("pusher_internal:") === 0) {
                this.handleInternalEvent(event);
              } else {
                var data = event.data;
                var metadata = {};
                if (event.user_id) {
                  metadata.user_id = event.user_id;
                }
                this.emit(eventName, data, metadata);
              }
            }
            handleInternalEvent(event) {
              var eventName = event.event;
              var data = event.data;
              switch (eventName) {
                case "pusher_internal:subscription_succeeded":
                  this.handleSubscriptionSucceededEvent(event);
                  break;
                case "pusher_internal:subscription_count":
                  this.handleSubscriptionCountEvent(event);
                  break;
                case "pusher_internal:member_added":
                  var addedMember = this.members.addMember(data);
                  this.emit("pusher:member_added", addedMember);
                  break;
                case "pusher_internal:member_removed":
                  var removedMember = this.members.removeMember(data);
                  if (removedMember) {
                    this.emit("pusher:member_removed", removedMember);
                  }
                  break;
              }
            }
            handleSubscriptionSucceededEvent(event) {
              this.subscriptionPending = false;
              this.subscribed = true;
              if (this.subscriptionCancelled) {
                this.pusher.unsubscribe(this.name);
              } else {
                this.members.onSubscription(event.data);
                this.emit("pusher:subscription_succeeded", this.members);
              }
            }
            disconnect() {
              this.members.reset();
              super.disconnect();
            }
          }
          var utf8 = __webpack_require__2(978);
          var base64 = __webpack_require__2(594);
          class EncryptedChannel extends PrivateChannel {
            constructor(name, pusher3, nacl) {
              super(name, pusher3);
              this.key = null;
              this.nacl = nacl;
            }
            authorize(socketId, callback) {
              super.authorize(socketId, (error, authData) => {
                if (error) {
                  callback(error, authData);
                  return;
                }
                let sharedSecret = authData["shared_secret"];
                if (!sharedSecret) {
                  callback(new Error(`No shared_secret key in auth payload for encrypted channel: ${this.name}`), null);
                  return;
                }
                this.key = (0, base64.decode)(sharedSecret);
                delete authData["shared_secret"];
                callback(null, authData);
              });
            }
            trigger(event, data) {
              throw new UnsupportedFeature("Client events are not currently supported for encrypted channels");
            }
            handleEvent(event) {
              var eventName = event.event;
              var data = event.data;
              if (eventName.indexOf("pusher_internal:") === 0 || eventName.indexOf("pusher:") === 0) {
                super.handleEvent(event);
                return;
              }
              this.handleEncryptedEvent(eventName, data);
            }
            handleEncryptedEvent(event, data) {
              if (!this.key) {
                logger.debug("Received encrypted event before key has been retrieved from the authEndpoint");
                return;
              }
              if (!data.ciphertext || !data.nonce) {
                logger.error("Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: " + data);
                return;
              }
              let cipherText = (0, base64.decode)(data.ciphertext);
              if (cipherText.length < this.nacl.secretbox.overheadLength) {
                logger.error(`Expected encrypted event ciphertext length to be ${this.nacl.secretbox.overheadLength}, got: ${cipherText.length}`);
                return;
              }
              let nonce = (0, base64.decode)(data.nonce);
              if (nonce.length < this.nacl.secretbox.nonceLength) {
                logger.error(`Expected encrypted event nonce length to be ${this.nacl.secretbox.nonceLength}, got: ${nonce.length}`);
                return;
              }
              let bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
              if (bytes === null) {
                logger.debug("Failed to decrypt an event, probably because it was encrypted with a different key. Fetching a new key from the authEndpoint...");
                this.authorize(this.pusher.connection.socket_id, (error, authData) => {
                  if (error) {
                    logger.error(`Failed to make a request to the authEndpoint: ${authData}. Unable to fetch new key, so dropping encrypted event`);
                    return;
                  }
                  bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
                  if (bytes === null) {
                    logger.error(`Failed to decrypt event with new key. Dropping encrypted event`);
                    return;
                  }
                  this.emit(event, this.getDataToEmit(bytes));
                  return;
                });
                return;
              }
              this.emit(event, this.getDataToEmit(bytes));
            }
            getDataToEmit(bytes) {
              let raw = (0, utf8.D4)(bytes);
              try {
                return JSON.parse(raw);
              } catch (_a) {
                return raw;
              }
            }
          }
          class ConnectionManager extends Dispatcher {
            constructor(key, options) {
              super();
              this.state = "initialized";
              this.connection = null;
              this.key = key;
              this.options = options;
              this.timeline = this.options.timeline;
              this.usingTLS = this.options.useTLS;
              this.errorCallbacks = this.buildErrorCallbacks();
              this.connectionCallbacks = this.buildConnectionCallbacks(this.errorCallbacks);
              this.handshakeCallbacks = this.buildHandshakeCallbacks(this.errorCallbacks);
              var Network2 = node_runtime.getNetwork();
              Network2.bind("online", () => {
                this.timeline.info({ netinfo: "online" });
                if (this.state === "connecting" || this.state === "unavailable") {
                  this.retryIn(0);
                }
              });
              Network2.bind("offline", () => {
                this.timeline.info({ netinfo: "offline" });
                if (this.connection) {
                  this.sendActivityCheck();
                }
              });
              this.updateStrategy();
            }
            switchCluster(key) {
              this.key = key;
              this.updateStrategy();
              this.retryIn(0);
            }
            connect() {
              if (this.connection || this.runner) {
                return;
              }
              if (!this.strategy.isSupported()) {
                this.updateState("failed");
                return;
              }
              this.updateState("connecting");
              this.startConnecting();
              this.setUnavailableTimer();
            }
            send(data) {
              if (this.connection) {
                return this.connection.send(data);
              } else {
                return false;
              }
            }
            send_event(name, data, channel) {
              if (this.connection) {
                return this.connection.send_event(name, data, channel);
              } else {
                return false;
              }
            }
            disconnect() {
              this.disconnectInternally();
              this.updateState("disconnected");
            }
            isUsingTLS() {
              return this.usingTLS;
            }
            startConnecting() {
              var callback = (error, handshake) => {
                if (error) {
                  this.runner = this.strategy.connect(0, callback);
                } else {
                  if (handshake.action === "error") {
                    this.emit("error", {
                      type: "HandshakeError",
                      error: handshake.error
                    });
                    this.timeline.error({ handshakeError: handshake.error });
                  } else {
                    this.abortConnecting();
                    this.handshakeCallbacks[handshake.action](handshake);
                  }
                }
              };
              this.runner = this.strategy.connect(0, callback);
            }
            abortConnecting() {
              if (this.runner) {
                this.runner.abort();
                this.runner = null;
              }
            }
            disconnectInternally() {
              this.abortConnecting();
              this.clearRetryTimer();
              this.clearUnavailableTimer();
              if (this.connection) {
                var connection = this.abandonConnection();
                connection.close();
              }
            }
            updateStrategy() {
              this.strategy = this.options.getStrategy({
                key: this.key,
                timeline: this.timeline,
                useTLS: this.usingTLS
              });
            }
            retryIn(delay) {
              this.timeline.info({ action: "retry", delay });
              if (delay > 0) {
                this.emit("connecting_in", Math.round(delay / 1e3));
              }
              this.retryTimer = new OneOffTimer(delay || 0, () => {
                this.disconnectInternally();
                this.connect();
              });
            }
            clearRetryTimer() {
              if (this.retryTimer) {
                this.retryTimer.ensureAborted();
                this.retryTimer = null;
              }
            }
            setUnavailableTimer() {
              this.unavailableTimer = new OneOffTimer(this.options.unavailableTimeout, () => {
                this.updateState("unavailable");
              });
            }
            clearUnavailableTimer() {
              if (this.unavailableTimer) {
                this.unavailableTimer.ensureAborted();
              }
            }
            sendActivityCheck() {
              this.stopActivityCheck();
              this.connection.ping();
              this.activityTimer = new OneOffTimer(this.options.pongTimeout, () => {
                this.timeline.error({ pong_timed_out: this.options.pongTimeout });
                this.retryIn(0);
              });
            }
            resetActivityCheck() {
              this.stopActivityCheck();
              if (this.connection && !this.connection.handlesActivityChecks()) {
                this.activityTimer = new OneOffTimer(this.activityTimeout, () => {
                  this.sendActivityCheck();
                });
              }
            }
            stopActivityCheck() {
              if (this.activityTimer) {
                this.activityTimer.ensureAborted();
              }
            }
            buildConnectionCallbacks(errorCallbacks) {
              return extend({}, errorCallbacks, {
                message: (message) => {
                  this.resetActivityCheck();
                  this.emit("message", message);
                },
                ping: () => {
                  this.send_event("pusher:pong", {});
                },
                activity: () => {
                  this.resetActivityCheck();
                },
                error: (error) => {
                  this.emit("error", error);
                },
                closed: () => {
                  this.abandonConnection();
                  if (this.shouldRetry()) {
                    this.retryIn(1e3);
                  }
                }
              });
            }
            buildHandshakeCallbacks(errorCallbacks) {
              return extend({}, errorCallbacks, {
                connected: (handshake) => {
                  this.activityTimeout = Math.min(this.options.activityTimeout, handshake.activityTimeout, handshake.connection.activityTimeout || Infinity);
                  this.clearUnavailableTimer();
                  this.setConnection(handshake.connection);
                  this.socket_id = this.connection.id;
                  this.updateState("connected", { socket_id: this.socket_id });
                }
              });
            }
            buildErrorCallbacks() {
              let withErrorEmitted = (callback) => {
                return (result) => {
                  if (result.error) {
                    this.emit("error", { type: "WebSocketError", error: result.error });
                  }
                  callback(result);
                };
              };
              return {
                tls_only: withErrorEmitted(() => {
                  this.usingTLS = true;
                  this.updateStrategy();
                  this.retryIn(0);
                }),
                refused: withErrorEmitted(() => {
                  this.disconnect();
                }),
                backoff: withErrorEmitted(() => {
                  this.retryIn(1e3);
                }),
                retry: withErrorEmitted(() => {
                  this.retryIn(0);
                })
              };
            }
            setConnection(connection) {
              this.connection = connection;
              for (var event in this.connectionCallbacks) {
                this.connection.bind(event, this.connectionCallbacks[event]);
              }
              this.resetActivityCheck();
            }
            abandonConnection() {
              if (!this.connection) {
                return;
              }
              this.stopActivityCheck();
              for (var event in this.connectionCallbacks) {
                this.connection.unbind(event, this.connectionCallbacks[event]);
              }
              var connection = this.connection;
              this.connection = null;
              return connection;
            }
            updateState(newState, data) {
              var previousState = this.state;
              this.state = newState;
              if (previousState !== newState) {
                var newStateDescription = newState;
                if (newStateDescription === "connected") {
                  newStateDescription += " with new socket ID " + data.socket_id;
                }
                logger.debug("State changed", previousState + " -> " + newStateDescription);
                this.timeline.info({ state: newState, params: data });
                this.emit("state_change", { previous: previousState, current: newState });
                this.emit(newState, data);
              }
            }
            shouldRetry() {
              return this.state === "connecting" || this.state === "connected";
            }
          }
          class Channels {
            constructor() {
              this.channels = {};
            }
            add(name, pusher3) {
              if (!this.channels[name]) {
                this.channels[name] = createChannel(name, pusher3);
              }
              return this.channels[name];
            }
            all() {
              return values(this.channels);
            }
            find(name) {
              return this.channels[name];
            }
            remove(name) {
              var channel = this.channels[name];
              delete this.channels[name];
              return channel;
            }
            disconnect() {
              objectApply(this.channels, function(channel) {
                channel.disconnect();
              });
            }
          }
          function createChannel(name, pusher3) {
            if (name.indexOf("private-encrypted-") === 0) {
              if (pusher3.config.nacl) {
                return factory.createEncryptedChannel(name, pusher3, pusher3.config.nacl);
              }
              let errMsg = "Tried to subscribe to a private-encrypted- channel but no nacl implementation available";
              let suffix = url_store.buildLogSuffix("encryptedChannelSupport");
              throw new UnsupportedFeature(`${errMsg}. ${suffix}`);
            } else if (name.indexOf("private-") === 0) {
              return factory.createPrivateChannel(name, pusher3);
            } else if (name.indexOf("presence-") === 0) {
              return factory.createPresenceChannel(name, pusher3);
            } else if (name.indexOf("#") === 0) {
              throw new BadChannelName('Cannot create a channel with name "' + name + '".');
            } else {
              return factory.createChannel(name, pusher3);
            }
          }
          var Factory = {
            createChannels() {
              return new Channels();
            },
            createConnectionManager(key, options) {
              return new ConnectionManager(key, options);
            },
            createChannel(name, pusher3) {
              return new Channel(name, pusher3);
            },
            createPrivateChannel(name, pusher3) {
              return new PrivateChannel(name, pusher3);
            },
            createPresenceChannel(name, pusher3) {
              return new PresenceChannel(name, pusher3);
            },
            createEncryptedChannel(name, pusher3, nacl) {
              return new EncryptedChannel(name, pusher3, nacl);
            },
            createTimelineSender(timeline, options) {
              return new TimelineSender(timeline, options);
            },
            createHandshake(transport, callback) {
              return new Handshake(transport, callback);
            },
            createAssistantToTheTransportManager(manager, transport, options) {
              return new AssistantToTheTransportManager(manager, transport, options);
            }
          };
          const factory = Factory;
          class TransportManager {
            constructor(options) {
              this.options = options || {};
              this.livesLeft = this.options.lives || Infinity;
            }
            getAssistant(transport) {
              return factory.createAssistantToTheTransportManager(this, transport, {
                minPingDelay: this.options.minPingDelay,
                maxPingDelay: this.options.maxPingDelay
              });
            }
            isAlive() {
              return this.livesLeft > 0;
            }
            reportDeath() {
              this.livesLeft -= 1;
            }
          }
          class SequentialStrategy {
            constructor(strategies, options) {
              this.strategies = strategies;
              this.loop = Boolean(options.loop);
              this.failFast = Boolean(options.failFast);
              this.timeout = options.timeout;
              this.timeoutLimit = options.timeoutLimit;
            }
            isSupported() {
              return any(this.strategies, util.method("isSupported"));
            }
            connect(minPriority, callback) {
              var strategies = this.strategies;
              var current = 0;
              var timeout = this.timeout;
              var runner = null;
              var tryNextStrategy = (error, handshake) => {
                if (handshake) {
                  callback(null, handshake);
                } else {
                  current = current + 1;
                  if (this.loop) {
                    current = current % strategies.length;
                  }
                  if (current < strategies.length) {
                    if (timeout) {
                      timeout = timeout * 2;
                      if (this.timeoutLimit) {
                        timeout = Math.min(timeout, this.timeoutLimit);
                      }
                    }
                    runner = this.tryStrategy(strategies[current], minPriority, { timeout, failFast: this.failFast }, tryNextStrategy);
                  } else {
                    callback(true);
                  }
                }
              };
              runner = this.tryStrategy(strategies[current], minPriority, { timeout, failFast: this.failFast }, tryNextStrategy);
              return {
                abort: function() {
                  runner.abort();
                },
                forceMinPriority: function(p2) {
                  minPriority = p2;
                  if (runner) {
                    runner.forceMinPriority(p2);
                  }
                }
              };
            }
            tryStrategy(strategy, minPriority, options, callback) {
              var timer = null;
              var runner = null;
              if (options.timeout > 0) {
                timer = new OneOffTimer(options.timeout, function() {
                  runner.abort();
                  callback(true);
                });
              }
              runner = strategy.connect(minPriority, function(error, handshake) {
                if (error && timer && timer.isRunning() && !options.failFast) {
                  return;
                }
                if (timer) {
                  timer.ensureAborted();
                }
                callback(error, handshake);
              });
              return {
                abort: function() {
                  if (timer) {
                    timer.ensureAborted();
                  }
                  runner.abort();
                },
                forceMinPriority: function(p2) {
                  runner.forceMinPriority(p2);
                }
              };
            }
          }
          class BestConnectedEverStrategy {
            constructor(strategies) {
              this.strategies = strategies;
            }
            isSupported() {
              return any(this.strategies, util.method("isSupported"));
            }
            connect(minPriority, callback) {
              return connect(this.strategies, minPriority, function(i, runners) {
                return function(error, handshake) {
                  runners[i].error = error;
                  if (error) {
                    if (allRunnersFailed(runners)) {
                      callback(true);
                    }
                    return;
                  }
                  apply(runners, function(runner) {
                    runner.forceMinPriority(handshake.transport.priority);
                  });
                  callback(null, handshake);
                };
              });
            }
          }
          function connect(strategies, minPriority, callbackBuilder) {
            var runners = map(strategies, function(strategy, i, _2, rs) {
              return strategy.connect(minPriority, callbackBuilder(i, rs));
            });
            return {
              abort: function() {
                apply(runners, abortRunner);
              },
              forceMinPriority: function(p2) {
                apply(runners, function(runner) {
                  runner.forceMinPriority(p2);
                });
              }
            };
          }
          function allRunnersFailed(runners) {
            return collections_all(runners, function(runner) {
              return Boolean(runner.error);
            });
          }
          function abortRunner(runner) {
            if (!runner.error && !runner.aborted) {
              runner.abort();
              runner.aborted = true;
            }
          }
          class WebSocketPrioritizedCachedStrategy {
            constructor(strategy, transports2, options) {
              this.strategy = strategy;
              this.transports = transports2;
              this.ttl = options.ttl || 1800 * 1e3;
              this.usingTLS = options.useTLS;
              this.timeline = options.timeline;
            }
            isSupported() {
              return this.strategy.isSupported();
            }
            connect(minPriority, callback) {
              var usingTLS = this.usingTLS;
              var info = fetchTransportCache(usingTLS);
              var cacheSkipCount = info && info.cacheSkipCount ? info.cacheSkipCount : 0;
              var strategies = [this.strategy];
              if (info && info.timestamp + this.ttl >= util.now()) {
                var transport = this.transports[info.transport];
                if (transport) {
                  if (["ws", "wss"].includes(info.transport) || cacheSkipCount > 3) {
                    this.timeline.info({
                      cached: true,
                      transport: info.transport,
                      latency: info.latency
                    });
                    strategies.push(new SequentialStrategy([transport], {
                      timeout: info.latency * 2 + 1e3,
                      failFast: true
                    }));
                  } else {
                    cacheSkipCount++;
                  }
                }
              }
              var startTimestamp = util.now();
              var runner = strategies.pop().connect(minPriority, function cb(error, handshake) {
                if (error) {
                  flushTransportCache(usingTLS);
                  if (strategies.length > 0) {
                    startTimestamp = util.now();
                    runner = strategies.pop().connect(minPriority, cb);
                  } else {
                    callback(error);
                  }
                } else {
                  storeTransportCache(usingTLS, handshake.transport.name, util.now() - startTimestamp, cacheSkipCount);
                  callback(null, handshake);
                }
              });
              return {
                abort: function() {
                  runner.abort();
                },
                forceMinPriority: function(p2) {
                  minPriority = p2;
                  if (runner) {
                    runner.forceMinPriority(p2);
                  }
                }
              };
            }
          }
          function getTransportCacheKey(usingTLS) {
            return "pusherTransport" + (usingTLS ? "TLS" : "NonTLS");
          }
          function fetchTransportCache(usingTLS) {
            var storage = node_runtime.getLocalStorage();
            if (storage) {
              try {
                var serializedCache = storage[getTransportCacheKey(usingTLS)];
                if (serializedCache) {
                  return JSON.parse(serializedCache);
                }
              } catch (e) {
                flushTransportCache(usingTLS);
              }
            }
            return null;
          }
          function storeTransportCache(usingTLS, transport, latency, cacheSkipCount) {
            var storage = node_runtime.getLocalStorage();
            if (storage) {
              try {
                storage[getTransportCacheKey(usingTLS)] = safeJSONStringify({
                  timestamp: util.now(),
                  transport,
                  latency,
                  cacheSkipCount
                });
              } catch (e) {
              }
            }
          }
          function flushTransportCache(usingTLS) {
            var storage = node_runtime.getLocalStorage();
            if (storage) {
              try {
                delete storage[getTransportCacheKey(usingTLS)];
              } catch (e) {
              }
            }
          }
          class DelayedStrategy {
            constructor(strategy, { delay: number }) {
              this.strategy = strategy;
              this.options = { delay: number };
            }
            isSupported() {
              return this.strategy.isSupported();
            }
            connect(minPriority, callback) {
              var strategy = this.strategy;
              var runner;
              var timer = new OneOffTimer(this.options.delay, function() {
                runner = strategy.connect(minPriority, callback);
              });
              return {
                abort: function() {
                  timer.ensureAborted();
                  if (runner) {
                    runner.abort();
                  }
                },
                forceMinPriority: function(p2) {
                  minPriority = p2;
                  if (runner) {
                    runner.forceMinPriority(p2);
                  }
                }
              };
            }
          }
          class IfStrategy {
            constructor(test, trueBranch, falseBranch) {
              this.test = test;
              this.trueBranch = trueBranch;
              this.falseBranch = falseBranch;
            }
            isSupported() {
              var branch = this.test() ? this.trueBranch : this.falseBranch;
              return branch.isSupported();
            }
            connect(minPriority, callback) {
              var branch = this.test() ? this.trueBranch : this.falseBranch;
              return branch.connect(minPriority, callback);
            }
          }
          class FirstConnectedStrategy {
            constructor(strategy) {
              this.strategy = strategy;
            }
            isSupported() {
              return this.strategy.isSupported();
            }
            connect(minPriority, callback) {
              var runner = this.strategy.connect(minPriority, function(error, handshake) {
                if (handshake) {
                  runner.abort();
                }
                callback(error, handshake);
              });
              return runner;
            }
          }
          function testSupportsStrategy(strategy) {
            return function() {
              return strategy.isSupported();
            };
          }
          var getDefaultStrategy = function(config, baseOptions, defineTransport2) {
            var definedTransports = {};
            function defineTransportStrategy(name, type, priority, options, manager) {
              var transport = defineTransport2(config, name, type, priority, options, manager);
              definedTransports[name] = transport;
              return transport;
            }
            var ws_options = Object.assign({}, baseOptions, {
              hostNonTLS: config.wsHost + ":" + config.wsPort,
              hostTLS: config.wsHost + ":" + config.wssPort,
              httpPath: config.wsPath
            });
            var wss_options = extend({}, ws_options, {
              useTLS: true
            });
            var http_options = Object.assign({}, baseOptions, {
              hostNonTLS: config.httpHost + ":" + config.httpPort,
              hostTLS: config.httpHost + ":" + config.httpsPort,
              httpPath: config.httpPath
            });
            var timeouts = {
              loop: true,
              timeout: 15e3,
              timeoutLimit: 6e4
            };
            var ws_manager = new TransportManager({
              minPingDelay: 1e4,
              maxPingDelay: config.activityTimeout
            });
            var streaming_manager = new TransportManager({
              lives: 2,
              minPingDelay: 1e4,
              maxPingDelay: config.activityTimeout
            });
            var ws_transport = defineTransportStrategy("ws", "ws", 3, ws_options, ws_manager);
            var wss_transport = defineTransportStrategy("wss", "ws", 3, wss_options, ws_manager);
            var xhr_streaming_transport = defineTransportStrategy("xhr_streaming", "xhr_streaming", 1, http_options, streaming_manager);
            var xhr_polling_transport = defineTransportStrategy("xhr_polling", "xhr_polling", 1, http_options);
            var ws_loop = new SequentialStrategy([ws_transport], timeouts);
            var wss_loop = new SequentialStrategy([wss_transport], timeouts);
            var streaming_loop = new SequentialStrategy([xhr_streaming_transport], timeouts);
            var polling_loop = new SequentialStrategy([xhr_polling_transport], timeouts);
            var http_loop = new SequentialStrategy([
              new IfStrategy(testSupportsStrategy(streaming_loop), new BestConnectedEverStrategy([
                streaming_loop,
                new DelayedStrategy(polling_loop, { delay: 4e3 })
              ]), polling_loop)
            ], timeouts);
            var wsStrategy;
            if (baseOptions.useTLS) {
              wsStrategy = new BestConnectedEverStrategy([
                ws_loop,
                new DelayedStrategy(http_loop, { delay: 2e3 })
              ]);
            } else {
              wsStrategy = new BestConnectedEverStrategy([
                ws_loop,
                new DelayedStrategy(wss_loop, { delay: 2e3 }),
                new DelayedStrategy(http_loop, { delay: 5e3 })
              ]);
            }
            return new WebSocketPrioritizedCachedStrategy(new FirstConnectedStrategy(new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_loop)), definedTransports, {
              ttl: 18e5,
              timeline: baseOptions.timeline,
              useTLS: baseOptions.useTLS
            });
          };
          const default_strategy = getDefaultStrategy;
          function transport_connection_initializer() {
            var self2 = this;
            self2.timeline.info(self2.buildTimelineMessage({
              transport: self2.name + (self2.options.useTLS ? "s" : "")
            }));
            if (self2.hooks.isInitialized()) {
              self2.changeState("initialized");
            } else {
              self2.onClose();
            }
          }
          const MAX_BUFFER_LENGTH = 256 * 1024;
          class HTTPRequest extends Dispatcher {
            constructor(hooks2, method, url) {
              super();
              this.hooks = hooks2;
              this.method = method;
              this.url = url;
            }
            start(payload) {
              this.position = 0;
              this.xhr = this.hooks.getRequest(this);
              this.unloader = () => {
                this.close();
              };
              node_runtime.addUnloadListener(this.unloader);
              this.xhr.open(this.method, this.url, true);
              if (this.xhr.setRequestHeader) {
                this.xhr.setRequestHeader("Content-Type", "application/json");
              }
              this.xhr.send(payload);
            }
            close() {
              if (this.unloader) {
                node_runtime.removeUnloadListener(this.unloader);
                this.unloader = null;
              }
              if (this.xhr) {
                this.hooks.abortRequest(this.xhr);
                this.xhr = null;
              }
            }
            onChunk(status, data) {
              while (true) {
                var chunk = this.advanceBuffer(data);
                if (chunk) {
                  this.emit("chunk", { status, data: chunk });
                } else {
                  break;
                }
              }
              if (this.isBufferTooLong(data)) {
                this.emit("buffer_too_long");
              }
            }
            advanceBuffer(buffer) {
              var unreadData = buffer.slice(this.position);
              var endOfLinePosition = unreadData.indexOf("\n");
              if (endOfLinePosition !== -1) {
                this.position += endOfLinePosition + 1;
                return unreadData.slice(0, endOfLinePosition);
              } else {
                return null;
              }
            }
            isBufferTooLong(buffer) {
              return this.position === buffer.length && buffer.length > MAX_BUFFER_LENGTH;
            }
          }
          var State;
          (function(State2) {
            State2[State2["CONNECTING"] = 0] = "CONNECTING";
            State2[State2["OPEN"] = 1] = "OPEN";
            State2[State2["CLOSED"] = 3] = "CLOSED";
          })(State || (State = {}));
          const state = State;
          var autoIncrement = 1;
          class HTTPSocket {
            constructor(hooks2, url) {
              this.hooks = hooks2;
              this.session = randomNumber(1e3) + "/" + randomString(8);
              this.location = getLocation(url);
              this.readyState = state.CONNECTING;
              this.openStream();
            }
            send(payload) {
              return this.sendRaw(JSON.stringify([payload]));
            }
            ping() {
              this.hooks.sendHeartbeat(this);
            }
            close(code, reason) {
              this.onClose(code, reason, true);
            }
            sendRaw(payload) {
              if (this.readyState === state.OPEN) {
                try {
                  node_runtime.createSocketRequest("POST", getUniqueURL(getSendURL(this.location, this.session))).start(payload);
                  return true;
                } catch (e) {
                  return false;
                }
              } else {
                return false;
              }
            }
            reconnect() {
              this.closeStream();
              this.openStream();
            }
            onClose(code, reason, wasClean) {
              this.closeStream();
              this.readyState = state.CLOSED;
              if (this.onclose) {
                this.onclose({
                  code,
                  reason,
                  wasClean
                });
              }
            }
            onChunk(chunk) {
              if (chunk.status !== 200) {
                return;
              }
              if (this.readyState === state.OPEN) {
                this.onActivity();
              }
              var payload;
              var type = chunk.data.slice(0, 1);
              switch (type) {
                case "o":
                  payload = JSON.parse(chunk.data.slice(1) || "{}");
                  this.onOpen(payload);
                  break;
                case "a":
                  payload = JSON.parse(chunk.data.slice(1) || "[]");
                  for (var i = 0; i < payload.length; i++) {
                    this.onEvent(payload[i]);
                  }
                  break;
                case "m":
                  payload = JSON.parse(chunk.data.slice(1) || "null");
                  this.onEvent(payload);
                  break;
                case "h":
                  this.hooks.onHeartbeat(this);
                  break;
                case "c":
                  payload = JSON.parse(chunk.data.slice(1) || "[]");
                  this.onClose(payload[0], payload[1], true);
                  break;
              }
            }
            onOpen(options) {
              if (this.readyState === state.CONNECTING) {
                if (options && options.hostname) {
                  this.location.base = replaceHost(this.location.base, options.hostname);
                }
                this.readyState = state.OPEN;
                if (this.onopen) {
                  this.onopen();
                }
              } else {
                this.onClose(1006, "Server lost session", true);
              }
            }
            onEvent(event) {
              if (this.readyState === state.OPEN && this.onmessage) {
                this.onmessage({ data: event });
              }
            }
            onActivity() {
              if (this.onactivity) {
                this.onactivity();
              }
            }
            onError(error) {
              if (this.onerror) {
                this.onerror(error);
              }
            }
            openStream() {
              this.stream = node_runtime.createSocketRequest("POST", getUniqueURL(this.hooks.getReceiveURL(this.location, this.session)));
              this.stream.bind("chunk", (chunk) => {
                this.onChunk(chunk);
              });
              this.stream.bind("finished", (status) => {
                this.hooks.onFinished(this, status);
              });
              this.stream.bind("buffer_too_long", () => {
                this.reconnect();
              });
              try {
                this.stream.start();
              } catch (error) {
                util.defer(() => {
                  this.onError(error);
                  this.onClose(1006, "Could not start streaming", false);
                });
              }
            }
            closeStream() {
              if (this.stream) {
                this.stream.unbind_all();
                this.stream.close();
                this.stream = null;
              }
            }
          }
          function getLocation(url) {
            var parts = /([^\?]*)\/*(\??.*)/.exec(url);
            return {
              base: parts[1],
              queryString: parts[2]
            };
          }
          function getSendURL(url, session) {
            return url.base + "/" + session + "/xhr_send";
          }
          function getUniqueURL(url) {
            var separator = url.indexOf("?") === -1 ? "?" : "&";
            return url + separator + "t=" + +/* @__PURE__ */ new Date() + "&n=" + autoIncrement++;
          }
          function replaceHost(url, hostname) {
            var urlParts = /(https?:\/\/)([^\/:]+)((\/|:)?.*)/.exec(url);
            return urlParts[1] + hostname + urlParts[3];
          }
          function randomNumber(max) {
            return node_runtime.randomInt(max);
          }
          function randomString(length) {
            var result = [];
            for (var i = 0; i < length; i++) {
              result.push(randomNumber(32).toString(32));
            }
            return result.join("");
          }
          const http_socket = HTTPSocket;
          var hooks = {
            getReceiveURL: function(url, session) {
              return url.base + "/" + session + "/xhr_streaming" + url.queryString;
            },
            onHeartbeat: function(socket) {
              socket.sendRaw("[]");
            },
            sendHeartbeat: function(socket) {
              socket.sendRaw("[]");
            },
            onFinished: function(socket, status) {
              socket.onClose(1006, "Connection interrupted (" + status + ")", false);
            }
          };
          const http_streaming_socket = hooks;
          var http_polling_socket_hooks = {
            getReceiveURL: function(url, session) {
              return url.base + "/" + session + "/xhr" + url.queryString;
            },
            onHeartbeat: function() {
            },
            sendHeartbeat: function(socket) {
              socket.sendRaw("[]");
            },
            onFinished: function(socket, status) {
              if (status === 200) {
                socket.reconnect();
              } else {
                socket.onClose(1006, "Connection interrupted (" + status + ")", false);
              }
            }
          };
          const http_polling_socket = http_polling_socket_hooks;
          var http_xhr_request_hooks = {
            getRequest: function(socket) {
              var Constructor = node_runtime.getXHRAPI();
              var xhr2 = new Constructor();
              xhr2.onreadystatechange = xhr2.onprogress = function() {
                switch (xhr2.readyState) {
                  case 3:
                    if (xhr2.responseText && xhr2.responseText.length > 0) {
                      socket.onChunk(xhr2.status, xhr2.responseText);
                    }
                    break;
                  case 4:
                    if (xhr2.responseText && xhr2.responseText.length > 0) {
                      socket.onChunk(xhr2.status, xhr2.responseText);
                    }
                    socket.emit("finished", xhr2.status);
                    socket.close();
                    break;
                }
              };
              return xhr2;
            },
            abortRequest: function(xhr2) {
              xhr2.onreadystatechange = null;
              xhr2.abort();
            }
          };
          const http_xhr_request = http_xhr_request_hooks;
          var HTTP = {
            createStreamingSocket(url) {
              return this.createSocket(http_streaming_socket, url);
            },
            createPollingSocket(url) {
              return this.createSocket(http_polling_socket, url);
            },
            createSocket(hooks2, url) {
              return new http_socket(hooks2, url);
            },
            createXHR(method, url) {
              return this.createRequest(http_xhr_request, method, url);
            },
            createRequest(hooks2, method, url) {
              return new HTTPRequest(hooks2, method, url);
            }
          };
          const http_http = HTTP;
          var Isomorphic = {
            getDefaultStrategy: default_strategy,
            Transports: transports,
            transportConnectionInitializer: transport_connection_initializer,
            HTTPFactory: http_http,
            setup(PusherClass) {
              PusherClass.ready();
            },
            getLocalStorage() {
              return void 0;
            },
            getClientFeatures() {
              return keys(filterObject({ ws: transports.ws }, function(t) {
                return t.isSupported({});
              }));
            },
            getProtocol() {
              return "http:";
            },
            isXHRSupported() {
              return true;
            },
            createSocketRequest(method, url) {
              if (this.isXHRSupported()) {
                return this.HTTPFactory.createXHR(method, url);
              } else {
                throw "Cross-origin HTTP requests are not supported";
              }
            },
            createXHR() {
              var Constructor = this.getXHRAPI();
              return new Constructor();
            },
            createWebSocket(url) {
              var Constructor = this.getWebSocketAPI();
              return new Constructor(url);
            },
            addUnloadListener(listener) {
            },
            removeUnloadListener(listener) {
            }
          };
          const runtime = Isomorphic;
          var websocket = __webpack_require__2(555);
          var XMLHttpRequest = __webpack_require__2(407);
          class NetInfo extends Dispatcher {
            isOnline() {
              return true;
            }
          }
          var Network = new NetInfo();
          var AuthRequestType;
          (function(AuthRequestType2) {
            AuthRequestType2["UserAuthentication"] = "user-authentication";
            AuthRequestType2["ChannelAuthorization"] = "channel-authorization";
          })(AuthRequestType || (AuthRequestType = {}));
          const ajax = function(context, query, authOptions, authRequestType, callback) {
            const xhr2 = node_runtime.createXHR();
            xhr2.open("POST", authOptions.endpoint, true);
            xhr2.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
            for (var headerName in authOptions.headers) {
              xhr2.setRequestHeader(headerName, authOptions.headers[headerName]);
            }
            if (authOptions.headersProvider != null) {
              let dynamicHeaders = authOptions.headersProvider();
              for (var headerName in dynamicHeaders) {
                xhr2.setRequestHeader(headerName, dynamicHeaders[headerName]);
              }
            }
            xhr2.onreadystatechange = function() {
              if (xhr2.readyState === 4) {
                if (xhr2.status === 200) {
                  let data;
                  let parsed = false;
                  try {
                    data = JSON.parse(xhr2.responseText);
                    parsed = true;
                  } catch (e) {
                    callback(new HTTPAuthError(200, `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${xhr2.responseText}`), null);
                  }
                  if (parsed) {
                    callback(null, data);
                  }
                } else {
                  let suffix = "";
                  switch (authRequestType) {
                    case AuthRequestType.UserAuthentication:
                      suffix = url_store.buildLogSuffix("authenticationEndpoint");
                      break;
                    case AuthRequestType.ChannelAuthorization:
                      suffix = `Clients must be authorized to join private or presence channels. ${url_store.buildLogSuffix("authorizationEndpoint")}`;
                      break;
                  }
                  callback(new HTTPAuthError(xhr2.status, `Unable to retrieve auth string from ${authRequestType.toString()} endpoint - received status: ${xhr2.status} from ${authOptions.endpoint}. ${suffix}`), null);
                }
              }
            };
            xhr2.send(query);
            return xhr2;
          };
          const xhr_auth = ajax;
          var getAgent = function(sender, useTLS) {
            return function(data, callback) {
              var scheme = "http" + (useTLS ? "s" : "") + "://";
              var url = scheme + (sender.host || sender.options.host) + sender.options.path;
              var query = buildQueryString(data);
              url += "/2?" + query;
              var xhr2 = node_runtime.createXHR();
              xhr2.open("GET", url, true);
              xhr2.onreadystatechange = function() {
                if (xhr2.readyState === 4) {
                  let { status, responseText } = xhr2;
                  if (status !== 200) {
                    logger.debug(`TimelineSender Error: received ${status} from stats.pusher.com`);
                    return;
                  }
                  try {
                    var { host } = JSON.parse(responseText);
                  } catch (e) {
                    logger.debug(`TimelineSenderError: invalid response ${responseText}`);
                  }
                  if (host) {
                    sender.host = host;
                  }
                }
              };
              xhr2.send();
            };
          };
          var xhr = {
            name: "xhr",
            getAgent
          };
          const xhr_timeline = xhr;
          var external_crypto_ = __webpack_require__2(982);
          const { getDefaultStrategy: runtime_getDefaultStrategy, Transports: runtime_Transports, setup, getProtocol, isXHRSupported, getLocalStorage, createXHR, createWebSocket, addUnloadListener, removeUnloadListener, transportConnectionInitializer, createSocketRequest, HTTPFactory } = runtime;
          const NodeJS = {
            getDefaultStrategy: runtime_getDefaultStrategy,
            Transports: runtime_Transports,
            setup,
            getProtocol,
            isXHRSupported,
            createSocketRequest,
            getLocalStorage,
            createXHR,
            createWebSocket,
            addUnloadListener,
            removeUnloadListener,
            transportConnectionInitializer,
            HTTPFactory,
            TimelineTransport: xhr_timeline,
            getAuthorizers() {
              return { ajax: xhr_auth };
            },
            getWebSocketAPI() {
              return websocket.Client;
            },
            getXHRAPI() {
              return XMLHttpRequest.z;
            },
            getNetwork() {
              return Network;
            },
            randomInt(max) {
              return (0, external_crypto_.randomInt)(max);
            }
          };
          const node_runtime = NodeJS;
          var TimelineLevel;
          (function(TimelineLevel2) {
            TimelineLevel2[TimelineLevel2["ERROR"] = 3] = "ERROR";
            TimelineLevel2[TimelineLevel2["INFO"] = 6] = "INFO";
            TimelineLevel2[TimelineLevel2["DEBUG"] = 7] = "DEBUG";
          })(TimelineLevel || (TimelineLevel = {}));
          const level = TimelineLevel;
          class Timeline {
            constructor(key, session, options) {
              this.key = key;
              this.session = session;
              this.events = [];
              this.options = options || {};
              this.sent = 0;
              this.uniqueID = 0;
            }
            log(level2, event) {
              if (level2 <= this.options.level) {
                this.events.push(extend({}, event, { timestamp: util.now() }));
                if (this.options.limit && this.events.length > this.options.limit) {
                  this.events.shift();
                }
              }
            }
            error(event) {
              this.log(level.ERROR, event);
            }
            info(event) {
              this.log(level.INFO, event);
            }
            debug(event) {
              this.log(level.DEBUG, event);
            }
            isEmpty() {
              return this.events.length === 0;
            }
            send(sendfn, callback) {
              var data = extend({
                session: this.session,
                bundle: this.sent + 1,
                key: this.key,
                lib: "js",
                version: this.options.version,
                cluster: this.options.cluster,
                features: this.options.features,
                timeline: this.events
              }, this.options.params);
              this.events = [];
              sendfn(data, (error, result) => {
                if (!error) {
                  this.sent++;
                }
                if (callback) {
                  callback(error, result);
                }
              });
              return true;
            }
            generateUniqueID() {
              this.uniqueID++;
              return this.uniqueID;
            }
          }
          class TransportStrategy {
            constructor(name, priority, transport, options) {
              this.name = name;
              this.priority = priority;
              this.transport = transport;
              this.options = options || {};
            }
            isSupported() {
              return this.transport.isSupported({
                useTLS: this.options.useTLS
              });
            }
            connect(minPriority, callback) {
              if (!this.isSupported()) {
                return failAttempt(new UnsupportedStrategy(), callback);
              } else if (this.priority < minPriority) {
                return failAttempt(new TransportPriorityTooLow(), callback);
              }
              var connected = false;
              var transport = this.transport.createConnection(this.name, this.priority, this.options.key, this.options);
              var handshake = null;
              var onInitialized = function() {
                transport.unbind("initialized", onInitialized);
                transport.connect();
              };
              var onOpen = function() {
                handshake = factory.createHandshake(transport, function(result) {
                  connected = true;
                  unbindListeners();
                  callback(null, result);
                });
              };
              var onError = function(error) {
                unbindListeners();
                callback(error);
              };
              var onClosed = function() {
                unbindListeners();
                var serializedTransport;
                serializedTransport = safeJSONStringify(transport);
                callback(new TransportClosed(serializedTransport));
              };
              var unbindListeners = function() {
                transport.unbind("initialized", onInitialized);
                transport.unbind("open", onOpen);
                transport.unbind("error", onError);
                transport.unbind("closed", onClosed);
              };
              transport.bind("initialized", onInitialized);
              transport.bind("open", onOpen);
              transport.bind("error", onError);
              transport.bind("closed", onClosed);
              transport.initialize();
              return {
                abort: () => {
                  if (connected) {
                    return;
                  }
                  unbindListeners();
                  if (handshake) {
                    handshake.close();
                  } else {
                    transport.close();
                  }
                },
                forceMinPriority: (p2) => {
                  if (connected) {
                    return;
                  }
                  if (this.priority < p2) {
                    if (handshake) {
                      handshake.close();
                    } else {
                      transport.close();
                    }
                  }
                }
              };
            }
          }
          function failAttempt(error, callback) {
            util.defer(function() {
              callback(error);
            });
            return {
              abort: function() {
              },
              forceMinPriority: function() {
              }
            };
          }
          const { Transports: strategy_builder_Transports } = node_runtime;
          var defineTransport = function(config, name, type, priority, options, manager) {
            var transportClass = strategy_builder_Transports[type];
            if (!transportClass) {
              throw new UnsupportedTransport(type);
            }
            var enabled = (!config.enabledTransports || arrayIndexOf(config.enabledTransports, name) !== -1) && (!config.disabledTransports || arrayIndexOf(config.disabledTransports, name) === -1);
            var transport;
            if (enabled) {
              options = Object.assign({ ignoreNullOrigin: config.ignoreNullOrigin }, options);
              transport = new TransportStrategy(name, priority, manager ? manager.getAssistant(transportClass) : transportClass, options);
            } else {
              transport = strategy_builder_UnsupportedStrategy;
            }
            return transport;
          };
          var strategy_builder_UnsupportedStrategy = {
            isSupported: function() {
              return false;
            },
            connect: function(_2, callback) {
              var deferred = util.defer(function() {
                callback(new UnsupportedStrategy());
              });
              return {
                abort: function() {
                  deferred.ensureAborted();
                },
                forceMinPriority: function() {
                }
              };
            }
          };
          function validateOptions(options) {
            if (options == null) {
              throw "You must pass an options object";
            }
            if (options.cluster == null) {
              throw "Options object must provide a cluster";
            }
            if ("disableStats" in options) {
              logger.warn("The disableStats option is deprecated in favor of enableStats");
            }
          }
          const composeChannelQuery = (params, authOptions) => {
            var query = "socket_id=" + encodeURIComponent(params.socketId);
            for (var key in authOptions.params) {
              query += "&" + encodeURIComponent(key) + "=" + encodeURIComponent(authOptions.params[key]);
            }
            if (authOptions.paramsProvider != null) {
              let dynamicParams = authOptions.paramsProvider();
              for (var key in dynamicParams) {
                query += "&" + encodeURIComponent(key) + "=" + encodeURIComponent(dynamicParams[key]);
              }
            }
            return query;
          };
          const UserAuthenticator = (authOptions) => {
            if (typeof node_runtime.getAuthorizers()[authOptions.transport] === "undefined") {
              throw `'${authOptions.transport}' is not a recognized auth transport`;
            }
            return (params, callback) => {
              const query = composeChannelQuery(params, authOptions);
              node_runtime.getAuthorizers()[authOptions.transport](node_runtime, query, authOptions, AuthRequestType.UserAuthentication, callback);
            };
          };
          const user_authenticator = UserAuthenticator;
          const channel_authorizer_composeChannelQuery = (params, authOptions) => {
            var query = "socket_id=" + encodeURIComponent(params.socketId);
            query += "&channel_name=" + encodeURIComponent(params.channelName);
            for (var key in authOptions.params) {
              query += "&" + encodeURIComponent(key) + "=" + encodeURIComponent(authOptions.params[key]);
            }
            if (authOptions.paramsProvider != null) {
              let dynamicParams = authOptions.paramsProvider();
              for (var key in dynamicParams) {
                query += "&" + encodeURIComponent(key) + "=" + encodeURIComponent(dynamicParams[key]);
              }
            }
            return query;
          };
          const ChannelAuthorizer = (authOptions) => {
            if (typeof node_runtime.getAuthorizers()[authOptions.transport] === "undefined") {
              throw `'${authOptions.transport}' is not a recognized auth transport`;
            }
            return (params, callback) => {
              const query = channel_authorizer_composeChannelQuery(params, authOptions);
              node_runtime.getAuthorizers()[authOptions.transport](node_runtime, query, authOptions, AuthRequestType.ChannelAuthorization, callback);
            };
          };
          const channel_authorizer = ChannelAuthorizer;
          const ChannelAuthorizerProxy = (pusher3, authOptions, channelAuthorizerGenerator) => {
            const deprecatedAuthorizerOptions = {
              authTransport: authOptions.transport,
              authEndpoint: authOptions.endpoint,
              auth: {
                params: authOptions.params,
                headers: authOptions.headers
              }
            };
            return (params, callback) => {
              const channel = pusher3.channel(params.channelName);
              const channelAuthorizer = channelAuthorizerGenerator(channel, deprecatedAuthorizerOptions);
              channelAuthorizer.authorize(params.socketId, callback);
            };
          };
          function getConfig(opts, pusher3) {
            let config = {
              activityTimeout: opts.activityTimeout || defaults.activityTimeout,
              cluster: opts.cluster,
              httpPath: opts.httpPath || defaults.httpPath,
              httpPort: opts.httpPort || defaults.httpPort,
              httpsPort: opts.httpsPort || defaults.httpsPort,
              pongTimeout: opts.pongTimeout || defaults.pongTimeout,
              statsHost: opts.statsHost || defaults.stats_host,
              unavailableTimeout: opts.unavailableTimeout || defaults.unavailableTimeout,
              wsPath: opts.wsPath || defaults.wsPath,
              wsPort: opts.wsPort || defaults.wsPort,
              wssPort: opts.wssPort || defaults.wssPort,
              enableStats: getEnableStatsConfig(opts),
              httpHost: getHttpHost(opts),
              useTLS: shouldUseTLS(opts),
              wsHost: getWebsocketHost(opts),
              userAuthenticator: buildUserAuthenticator(opts),
              channelAuthorizer: buildChannelAuthorizer(opts, pusher3)
            };
            if ("disabledTransports" in opts)
              config.disabledTransports = opts.disabledTransports;
            if ("enabledTransports" in opts)
              config.enabledTransports = opts.enabledTransports;
            if ("ignoreNullOrigin" in opts)
              config.ignoreNullOrigin = opts.ignoreNullOrigin;
            if ("timelineParams" in opts)
              config.timelineParams = opts.timelineParams;
            if ("nacl" in opts) {
              config.nacl = opts.nacl;
            }
            return config;
          }
          function getHttpHost(opts) {
            if (opts.httpHost) {
              return opts.httpHost;
            }
            if (opts.cluster) {
              return `sockjs-${opts.cluster}.pusher.com`;
            }
            return defaults.httpHost;
          }
          function getWebsocketHost(opts) {
            if (opts.wsHost) {
              return opts.wsHost;
            }
            return getWebsocketHostFromCluster(opts.cluster);
          }
          function getWebsocketHostFromCluster(cluster) {
            return `ws-${cluster}.pusher.com`;
          }
          function shouldUseTLS(opts) {
            if (node_runtime.getProtocol() === "https:") {
              return true;
            } else if (opts.forceTLS === false) {
              return false;
            }
            return true;
          }
          function getEnableStatsConfig(opts) {
            if ("enableStats" in opts) {
              return opts.enableStats;
            }
            if ("disableStats" in opts) {
              return !opts.disableStats;
            }
            return false;
          }
          const hasCustomHandler = (auth) => {
            return "customHandler" in auth && auth["customHandler"] != null;
          };
          function buildUserAuthenticator(opts) {
            const userAuthentication = Object.assign(Object.assign({}, defaults.userAuthentication), opts.userAuthentication);
            if (hasCustomHandler(userAuthentication)) {
              return userAuthentication["customHandler"];
            }
            return user_authenticator(userAuthentication);
          }
          function buildChannelAuth(opts, pusher3) {
            let channelAuthorization;
            if ("channelAuthorization" in opts) {
              channelAuthorization = Object.assign(Object.assign({}, defaults.channelAuthorization), opts.channelAuthorization);
            } else {
              channelAuthorization = {
                transport: opts.authTransport || defaults.authTransport,
                endpoint: opts.authEndpoint || defaults.authEndpoint
              };
              if ("auth" in opts) {
                if ("params" in opts.auth)
                  channelAuthorization.params = opts.auth.params;
                if ("headers" in opts.auth)
                  channelAuthorization.headers = opts.auth.headers;
              }
              if ("authorizer" in opts) {
                return {
                  customHandler: ChannelAuthorizerProxy(pusher3, channelAuthorization, opts.authorizer)
                };
              }
            }
            return channelAuthorization;
          }
          function buildChannelAuthorizer(opts, pusher3) {
            const channelAuthorization = buildChannelAuth(opts, pusher3);
            if (hasCustomHandler(channelAuthorization)) {
              return channelAuthorization["customHandler"];
            }
            return channel_authorizer(channelAuthorization);
          }
          class WatchlistFacade extends Dispatcher {
            constructor(pusher3) {
              super(function(eventName, data) {
                logger.debug(`No callbacks on watchlist events for ${eventName}`);
              });
              this.pusher = pusher3;
              this.bindWatchlistInternalEvent();
            }
            handleEvent(pusherEvent) {
              pusherEvent.data.events.forEach((watchlistEvent) => {
                this.emit(watchlistEvent.name, watchlistEvent);
              });
            }
            bindWatchlistInternalEvent() {
              this.pusher.connection.bind("message", (pusherEvent) => {
                var eventName = pusherEvent.event;
                if (eventName === "pusher_internal:watchlist_events") {
                  this.handleEvent(pusherEvent);
                }
              });
            }
          }
          function flatPromise() {
            let resolve, reject;
            const promise = new Promise((res, rej) => {
              resolve = res;
              reject = rej;
            });
            return { promise, resolve, reject };
          }
          const flat_promise = flatPromise;
          class UserFacade extends Dispatcher {
            constructor(pusher3) {
              super(function(eventName, data) {
                logger.debug("No callbacks on user for " + eventName);
              });
              this.signin_requested = false;
              this.user_data = null;
              this.serverToUserChannel = null;
              this.signinDonePromise = null;
              this._signinDoneResolve = null;
              this._onAuthorize = (err, authData) => {
                if (err) {
                  logger.warn(`Error during signin: ${err}`);
                  this._cleanup();
                  return;
                }
                this.pusher.send_event("pusher:signin", {
                  auth: authData.auth,
                  user_data: authData.user_data
                });
              };
              this.pusher = pusher3;
              this.pusher.connection.bind("state_change", ({ previous, current }) => {
                if (previous !== "connected" && current === "connected") {
                  this._signin();
                }
                if (previous === "connected" && current !== "connected") {
                  this._cleanup();
                  this._newSigninPromiseIfNeeded();
                }
              });
              this.watchlist = new WatchlistFacade(pusher3);
              this.pusher.connection.bind("message", (event) => {
                var eventName = event.event;
                if (eventName === "pusher:signin_success") {
                  this._onSigninSuccess(event.data);
                }
                if (this.serverToUserChannel && this.serverToUserChannel.name === event.channel) {
                  this.serverToUserChannel.handleEvent(event);
                }
              });
            }
            signin() {
              if (this.signin_requested) {
                return;
              }
              this.signin_requested = true;
              this._signin();
            }
            _signin() {
              if (!this.signin_requested) {
                return;
              }
              this._newSigninPromiseIfNeeded();
              if (this.pusher.connection.state !== "connected") {
                return;
              }
              this.pusher.config.userAuthenticator({
                socketId: this.pusher.connection.socket_id
              }, this._onAuthorize);
            }
            _onSigninSuccess(data) {
              try {
                this.user_data = JSON.parse(data.user_data);
              } catch (e) {
                logger.error(`Failed parsing user data after signin: ${data.user_data}`);
                this._cleanup();
                return;
              }
              if (typeof this.user_data.id !== "string" || this.user_data.id === "") {
                logger.error(`user_data doesn't contain an id. user_data: ${this.user_data}`);
                this._cleanup();
                return;
              }
              this._signinDoneResolve();
              this._subscribeChannels();
            }
            _subscribeChannels() {
              const ensure_subscribed = (channel) => {
                if (channel.subscriptionPending && channel.subscriptionCancelled) {
                  channel.reinstateSubscription();
                } else if (!channel.subscriptionPending && this.pusher.connection.state === "connected") {
                  channel.subscribe();
                }
              };
              this.serverToUserChannel = new Channel(`#server-to-user-${this.user_data.id}`, this.pusher);
              this.serverToUserChannel.bind_global((eventName, data) => {
                if (eventName.indexOf("pusher_internal:") === 0 || eventName.indexOf("pusher:") === 0) {
                  return;
                }
                this.emit(eventName, data);
              });
              ensure_subscribed(this.serverToUserChannel);
            }
            _cleanup() {
              this.user_data = null;
              if (this.serverToUserChannel) {
                this.serverToUserChannel.unbind_all();
                this.serverToUserChannel.disconnect();
                this.serverToUserChannel = null;
              }
              if (this.signin_requested) {
                this._signinDoneResolve();
              }
            }
            _newSigninPromiseIfNeeded() {
              if (!this.signin_requested) {
                return;
              }
              if (this.signinDonePromise && !this.signinDonePromise.done) {
                return;
              }
              const { promise, resolve } = flat_promise();
              promise.done = false;
              const setDone = () => {
                promise.done = true;
              };
              promise.then(setDone).catch(setDone);
              this.signinDonePromise = promise;
              this._signinDoneResolve = resolve;
            }
          }
          class Pusher2 {
            static ready() {
              Pusher2.isReady = true;
              for (var i = 0, l2 = Pusher2.instances.length; i < l2; i++) {
                Pusher2.instances[i].connect();
              }
            }
            static getClientFeatures() {
              return keys(filterObject({ ws: node_runtime.Transports.ws }, function(t) {
                return t.isSupported({});
              }));
            }
            constructor(app_key, options) {
              checkAppKey(app_key);
              validateOptions(options);
              this.key = app_key;
              this.options = options;
              this.config = getConfig(this.options, this);
              this.channels = factory.createChannels();
              this.global_emitter = new Dispatcher();
              this.sessionID = node_runtime.randomInt(1e9);
              this.timeline = new Timeline(this.key, this.sessionID, {
                cluster: this.config.cluster,
                features: Pusher2.getClientFeatures(),
                params: this.config.timelineParams || {},
                limit: 50,
                level: level.INFO,
                version: defaults.VERSION
              });
              if (this.config.enableStats) {
                this.timelineSender = factory.createTimelineSender(this.timeline, {
                  host: this.config.statsHost,
                  path: "/timeline/v2/" + node_runtime.TimelineTransport.name
                });
              }
              var getStrategy = (options2) => {
                return node_runtime.getDefaultStrategy(this.config, options2, defineTransport);
              };
              this.connection = factory.createConnectionManager(this.key, {
                getStrategy,
                timeline: this.timeline,
                activityTimeout: this.config.activityTimeout,
                pongTimeout: this.config.pongTimeout,
                unavailableTimeout: this.config.unavailableTimeout,
                useTLS: Boolean(this.config.useTLS)
              });
              this.connection.bind("connected", () => {
                this.subscribeAll();
                if (this.timelineSender) {
                  this.timelineSender.send(this.connection.isUsingTLS());
                }
              });
              this.connection.bind("message", (event) => {
                var eventName = event.event;
                var internal = eventName.indexOf("pusher_internal:") === 0;
                if (event.channel) {
                  var channel = this.channel(event.channel);
                  if (channel) {
                    channel.handleEvent(event);
                  }
                }
                if (!internal) {
                  this.global_emitter.emit(event.event, event.data);
                }
              });
              this.connection.bind("connecting", () => {
                this.channels.disconnect();
              });
              this.connection.bind("disconnected", () => {
                this.channels.disconnect();
              });
              this.connection.bind("error", (err) => {
                logger.warn(err);
              });
              Pusher2.instances.push(this);
              this.timeline.info({ instances: Pusher2.instances.length });
              this.user = new UserFacade(this);
              if (Pusher2.isReady) {
                this.connect();
              }
            }
            switchCluster(options) {
              const { appKey, cluster } = options;
              this.key = appKey;
              this.options = Object.assign(Object.assign({}, this.options), { cluster });
              this.config = getConfig(this.options, this);
              this.connection.switchCluster(this.key);
            }
            channel(name) {
              return this.channels.find(name);
            }
            allChannels() {
              return this.channels.all();
            }
            connect() {
              this.connection.connect();
              if (this.timelineSender) {
                if (!this.timelineSenderTimer) {
                  var usingTLS = this.connection.isUsingTLS();
                  var timelineSender = this.timelineSender;
                  this.timelineSenderTimer = new PeriodicTimer(6e4, function() {
                    timelineSender.send(usingTLS);
                  });
                }
              }
            }
            disconnect() {
              this.connection.disconnect();
              if (this.timelineSenderTimer) {
                this.timelineSenderTimer.ensureAborted();
                this.timelineSenderTimer = null;
              }
            }
            bind(event_name, callback, context) {
              this.global_emitter.bind(event_name, callback, context);
              return this;
            }
            unbind(event_name, callback, context) {
              this.global_emitter.unbind(event_name, callback, context);
              return this;
            }
            bind_global(callback) {
              this.global_emitter.bind_global(callback);
              return this;
            }
            unbind_global(callback) {
              this.global_emitter.unbind_global(callback);
              return this;
            }
            unbind_all(callback) {
              this.global_emitter.unbind_all();
              return this;
            }
            subscribeAll() {
              var channelName;
              for (channelName in this.channels.channels) {
                if (this.channels.channels.hasOwnProperty(channelName)) {
                  this.subscribe(channelName);
                }
              }
            }
            subscribe(channel_name) {
              var channel = this.channels.add(channel_name, this);
              if (channel.subscriptionPending && channel.subscriptionCancelled) {
                channel.reinstateSubscription();
              } else if (!channel.subscriptionPending && this.connection.state === "connected") {
                channel.subscribe();
              }
              return channel;
            }
            unsubscribe(channel_name) {
              var channel = this.channels.find(channel_name);
              if (channel && channel.subscriptionPending) {
                channel.cancelSubscription();
              } else {
                channel = this.channels.remove(channel_name);
                if (channel && channel.subscribed) {
                  channel.unsubscribe();
                }
              }
            }
            send_event(event_name, data, channel) {
              return this.connection.send_event(event_name, data, channel);
            }
            shouldUseTLS() {
              return this.config.useTLS;
            }
            signin() {
              this.user.signin();
            }
          }
          Pusher2.instances = [];
          Pusher2.isReady = false;
          Pusher2.logToConsole = false;
          Pusher2.Runtime = node_runtime;
          Pusher2.ScriptReceivers = node_runtime.ScriptReceivers;
          Pusher2.DependenciesReceivers = node_runtime.DependenciesReceivers;
          Pusher2.auth_callbacks = node_runtime.auth_callbacks;
          const pusher2 = Pusher2;
          function checkAppKey(key) {
            if (key === null || key === void 0) {
              throw "You must pass your app key when you instantiate Pusher.";
            }
          }
          node_runtime.setup(Pusher2);
          var nacl_fast = __webpack_require__2(601);
          class PusherWithEncryption extends pusher2 {
            constructor(app_key, options) {
              pusher2.logToConsole = PusherWithEncryption.logToConsole;
              pusher2.log = PusherWithEncryption.log;
              validateOptions(options);
              options.nacl = nacl_fast;
              super(app_key, options);
            }
          }
        },
        /***/
        613(module2) {
          module2.exports = require$$4$2;
        },
        /***/
        181(module2) {
          module2.exports = require$$1$1;
        },
        /***/
        317(module2) {
          module2.exports = require$$2;
        },
        /***/
        982(module2) {
          module2.exports = require$$1;
        },
        /***/
        434(module2) {
          module2.exports = require$$4$1;
        },
        /***/
        896(module2) {
          module2.exports = require$$6;
        },
        /***/
        611(module2) {
          module2.exports = require$$3;
        },
        /***/
        692(module2) {
          module2.exports = require$$4;
        },
        /***/
        278(module2) {
          module2.exports = require$$8;
        },
        /***/
        203(module2) {
          module2.exports = stream;
        },
        /***/
        756(module2) {
          module2.exports = require$$10;
        },
        /***/
        16(module2) {
          module2.exports = require$$5;
        },
        /***/
        23(module2) {
          module2.exports = require$$0;
        }
        /******/
      };
      var __webpack_module_cache__ = {};
      function __webpack_require__(moduleId) {
        var cachedModule = __webpack_module_cache__[moduleId];
        if (cachedModule !== void 0) {
          return cachedModule.exports;
        }
        var module2 = __webpack_module_cache__[moduleId] = {
          /******/
          // no module.id needed
          /******/
          // no module.loaded needed
          /******/
          exports: {}
          /******/
        };
        __webpack_modules__[moduleId].call(module2.exports, module2, module2.exports, __webpack_require__);
        return module2.exports;
      }
      (() => {
        __webpack_require__.d = (exports$1, definition) => {
          for (var key in definition) {
            if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports$1, key)) {
              Object.defineProperty(exports$1, key, { enumerable: true, get: definition[key] });
            }
          }
        };
      })();
      (() => {
        __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
      })();
      var __webpack_exports__ = __webpack_require__(42);
      module.exports.Pusher = __webpack_exports__;
    })();
  })(pusher);
  return pusher.exports;
}
var pusherExports = requirePusher();
const Pusher = /* @__PURE__ */ getDefaultExportFromCjs(pusherExports);
export {
  E,
  Pusher as P
};