hypha-rpc 0.1.0-post5

package/dist/hypha-rpc-websocket.js

@@ -0,0 +1,4688 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define("hyphaWebsocketClient", [], factory);
+	else if(typeof exports === 'object')
+		exports["hyphaWebsocketClient"] = factory();
+	else
+		root["hyphaWebsocketClient"] = factory();
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./src/rpc.js":
+/*!********************!*\
+  !*** ./src/rpc.js ***!
+  \********************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   API_VERSION: () => (/* binding */ API_VERSION),
+/* harmony export */   RPC: () => (/* binding */ RPC)
+/* harmony export */ });
+/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils.js */ "./src/utils.js");
+/* harmony import */ var _msgpack_msgpack__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @msgpack/msgpack */ "./node_modules/@msgpack/msgpack/dist.es5+esm/decode.mjs");
+/* harmony import */ var _msgpack_msgpack__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @msgpack/msgpack */ "./node_modules/@msgpack/msgpack/dist.es5+esm/encode.mjs");
+/**
+ * Contains the RPC object used both by the application
+ * site, and by each plugin
+ */
+
+
+
+
+const API_VERSION = "0.3.0";
+const CHUNK_SIZE = 1024 * 500;
+
+const ArrayBufferView = Object.getPrototypeOf(
+  Object.getPrototypeOf(new Uint8Array()),
+).constructor;
+
+function _appendBuffer(buffer1, buffer2) {
+  const tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
+  tmp.set(new Uint8Array(buffer1), 0);
+  tmp.set(new Uint8Array(buffer2), buffer1.byteLength);
+  return tmp.buffer;
+}
+
+function indexObject(obj, is) {
+  if (!is) throw new Error("undefined index");
+  if (typeof is === "string") return indexObject(obj, is.split("."));
+  else if (is.length === 0) return obj;
+  else return indexObject(obj[is[0]], is.slice(1));
+}
+function getFunctionInfo(func) {
+  const funcString = func.toString();
+
+  // Extract function name
+  const nameMatch = funcString.match(/function\s*(\w*)/);
+  const name = (nameMatch && nameMatch[1]) || "";
+
+  // Extract function parameters, excluding comments
+  const paramsMatch = funcString.match(/\(([^)]*)\)/);
+  let params = "";
+  if (paramsMatch) {
+    params = paramsMatch[1]
+      .split(",")
+      .map((p) =>
+        p
+          .replace(/\/\*.*?\*\//g, "") // Remove block comments
+          .replace(/\/\/.*$/g, ""),
+      ) // Remove line comments
+      .filter((p) => p.trim().length > 0) // Remove empty strings after removing comments
+      .map((p) => p.trim()) // Trim remaining whitespace
+      .join(", ");
+  }
+
+  // Extract function docstring (block comment)
+  let docMatch = funcString.match(/\)\s*\{\s*\/\*([\s\S]*?)\*\//);
+  const docstringBlock = (docMatch && docMatch[1].trim()) || "";
+
+  // Extract function docstring (line comment)
+  docMatch = funcString.match(/\)\s*\{\s*(\/\/[\s\S]*?)\n\s*[^\s\/]/);
+  const docstringLine =
+    (docMatch &&
+      docMatch[1]
+        .split("\n")
+        .map((s) => s.replace(/^\/\/\s*/, "").trim())
+        .join("\n")) ||
+    "";
+
+  const docstring = docstringBlock || docstringLine;
+  return (
+    name &&
+    params.length > 0 && {
+      name: name,
+      sig: params,
+      doc: docstring,
+    }
+  );
+}
+
+function concatArrayBuffers(buffers) {
+  var buffersLengths = buffers.map(function (b) {
+      return b.byteLength;
+    }),
+    totalBufferlength = buffersLengths.reduce(function (p, c) {
+      return p + c;
+    }, 0),
+    unit8Arr = new Uint8Array(totalBufferlength);
+  buffersLengths.reduce(function (p, c, i) {
+    unit8Arr.set(new Uint8Array(buffers[i]), p);
+    return p + c;
+  }, 0);
+  return unit8Arr.buffer;
+}
+
+class Timer {
+  constructor(timeout, callback, args, label) {
+    this._timeout = timeout;
+    this._callback = callback;
+    this._args = args;
+    this._label = label || "timer";
+    this._task = null;
+    this.started = false;
+  }
+
+  start() {
+    if (this.started) {
+      this.reset();
+    } else {
+      this._task = setTimeout(() => {
+        this._callback.apply(this, this._args);
+      }, this._timeout * 1000);
+      this.started = true;
+    }
+  }
+
+  clear() {
+    if (this._task) {
+      clearTimeout(this._task);
+      this._task = null;
+      this.started = false;
+    } else {
+      console.warn(`Clearing a timer (${this._label}) which is not started`);
+    }
+  }
+
+  reset() {
+    if (this._task) {
+      clearTimeout(this._task);
+    }
+    this._task = setTimeout(() => {
+      this._callback.apply(this, this._args);
+    }, this._timeout * 1000);
+    this.started = true;
+  }
+}
+
+/**
+ * RPC object represents a single site in the
+ * communication protocol between the application and the plugin
+ *
+ * @param {Object} connection a special object allowing to send
+ * and receive messages from the opposite site (basically it
+ * should only provide send() and onMessage() methods)
+ */
+class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
+  constructor(
+    connection,
+    {
+      client_id = null,
+      manager_id = null,
+      default_context = null,
+      name = null,
+      codecs = null,
+      method_timeout = null,
+      max_message_buffer_size = 0,
+      debug = false,
+      workspace = null,
+      silent = false,
+      app_id = null,
+    },
+  ) {
+    super(debug);
+    this._codecs = codecs || {};
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(client_id && typeof client_id === "string");
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(client_id, "client_id is required");
+    this._client_id = client_id;
+    this._name = name;
+    this._app_id = app_id || "*";
+    this._local_workspace = workspace;
+    this.manager_id = manager_id;
+    this._silent = silent;
+    this.default_context = default_context || {};
+    this._method_annotations = new WeakMap();
+    this._max_message_buffer_size = max_message_buffer_size;
+    this._chunk_store = {};
+    this._method_timeout = method_timeout || 30;
+
+    // make sure there is an execute function
+    this._services = {};
+    this._object_store = {
+      services: this._services,
+    };
+
+    if (connection) {
+      this.add_service({
+        id: "built-in",
+        type: "built-in",
+        name: `Built-in services for ${this._local_workspace}/${this._client_id}`,
+        config: { require_context: true, visibility: "public" },
+        ping: this._ping.bind(this),
+        get_service: this.get_local_service.bind(this),
+        register_service: this.register_service.bind(this),
+        message_cache: {
+          create: this._create_message.bind(this),
+          append: this._append_message.bind(this),
+          process: this._process_message.bind(this),
+          remove: this._remove_message.bind(this),
+        },
+      });
+      this.on("method", this._handle_method.bind(this));
+
+      (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(connection.emit_message && connection.on_message);
+      this._emit_message = connection.emit_message.bind(connection);
+      connection.on_message(this._on_message.bind(this));
+      this._connection = connection;
+      const updateServices = async () => {
+        if (!this._silent && this.manager_id) {
+          console.log("Connection established, reporting services...");
+          for (let service of Object.values(this._services)) {
+            const serviceInfo = this._extract_service_info(service);
+            await this.emit({
+              type: "service-added",
+              to: "*/" + this.manager_id,
+              service: serviceInfo,
+            });
+          }
+        }
+      }
+      connection.on_connect(updateServices);
+      updateServices();
+    } else {
+      this._emit_message = function () {
+        console.log("No connection to emit message");
+      };
+    }
+  }
+
+  register_codec(config) {
+    if (!config["name"] || (!config["encoder"] && !config["decoder"])) {
+      throw new Error(
+        "Invalid codec format, please make sure you provide a name, type, encoder and decoder.",
+      );
+    } else {
+      if (config.type) {
+        for (let k of Object.keys(this._codecs)) {
+          if (this._codecs[k].type === config.type || k === config.name) {
+            delete this._codecs[k];
+            console.warn("Remove duplicated codec: " + k);
+          }
+        }
+      }
+      this._codecs[config["name"]] = config;
+    }
+  }
+
+  async _ping(msg, context) {
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(msg == "ping");
+    return "pong";
+  }
+
+  async ping(client_id, timeout) {
+    let method = this._generate_remote_method({
+      _rtarget: client_id,
+      _rmethod: "services.built-in.ping",
+      _rpromise: true,
+      _rdoc: "Ping a remote client",
+      _rsig: "ping(msg)",
+    });
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)((await method("ping", timeout)) == "pong");
+  }
+
+  _create_message(key, heartbeat, overwrite, context) {
+    if (heartbeat) {
+      if (!this._object_store[key]) {
+        throw new Error(`session does not exist anymore: ${key}`);
+      }
+      this._object_store[key]["timer"].reset();
+    }
+
+    if (!this._object_store["message_cache"]) {
+      this._object_store["message_cache"] = {};
+    }
+    if (!overwrite && this._object_store["message_cache"][key]) {
+      throw new Error(
+        `Message with the same key (${key}) already exists in the cache store, please use overwrite=true or remove it first.`,
+      );
+    }
+
+    this._object_store["message_cache"][key] = [];
+  }
+
+  _append_message(key, data, heartbeat, context) {
+    if (heartbeat) {
+      if (!this._object_store[key]) {
+        throw new Error(`session does not exist anymore: ${key}`);
+      }
+      this._object_store[key]["timer"].reset();
+    }
+    const cache = this._object_store["message_cache"];
+    if (!cache[key]) {
+      throw new Error(`Message with key ${key} does not exists.`);
+    }
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(data instanceof ArrayBufferView);
+    cache[key].push(data);
+  }
+
+  _remove_message(key, context) {
+    const cache = this._object_store["message_cache"];
+    if (!cache[key]) {
+      throw new Error(`Message with key ${key} does not exists.`);
+    }
+    delete cache[key];
+  }
+
+  _process_message(key, heartbeat, context) {
+    if (heartbeat) {
+      if (!this._object_store[key]) {
+        throw new Error(`session does not exist anymore: ${key}`);
+      }
+      this._object_store[key]["timer"].reset();
+    }
+    const cache = this._object_store["message_cache"];
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(!!context, "Context is required");
+    if (!cache[key]) {
+      throw new Error(`Message with key ${key} does not exists.`);
+    }
+    cache[key] = concatArrayBuffers(cache[key]);
+    console.debug(`Processing message ${key} (bytes=${cache[key].byteLength})`);
+    let unpacker = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_1__.decodeMulti)(cache[key]);
+    const { done, value } = unpacker.next();
+    const main = value;
+    // Make sure the fields are from trusted source
+    Object.assign(main, {
+      from: context.from,
+      to: context.to,
+      user: context.user,
+    });
+    main["ctx"] = JSON.parse(JSON.stringify(main));
+    Object.assign(main["ctx"], this.default_context);
+    if (!done) {
+      let extra = unpacker.next();
+      Object.assign(main, extra.value);
+    }
+    this._fire(main["type"], main);
+    console.debug(
+      this._client_id,
+      `Processed message ${key} (bytes=${cache[key].byteLength})`,
+    );
+    delete cache[key];
+  }
+
+  _on_message(message) {
+    try {
+      (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(message instanceof ArrayBuffer);
+      let unpacker = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_1__.decodeMulti)(message);
+      const { done, value } = unpacker.next();
+      const main = value;
+      // Add trusted context to the method call
+      main["ctx"] = JSON.parse(JSON.stringify(main));
+      Object.assign(main["ctx"], this.default_context);
+      if (!done) {
+        let extra = unpacker.next();
+        Object.assign(main, extra.value);
+      }
+      this._fire(main["type"], main);
+    } catch (error) {
+      console.error("Failed to process message", error);
+    }
+  }
+
+  reset() {
+    this._event_handlers = {};
+    this._services = {};
+  }
+
+  async disconnect() {
+    this._fire("disconnect");
+    await this._connection.disconnect();
+  }
+
+  async get_manager_service(timeout) {
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(this.manager_id, "Manager id is not set");
+    const svc = await this.get_remote_service(
+      `*/${this.manager_id}:default`,
+      timeout,
+    );
+    return svc;
+  }
+
+  get_all_local_services() {
+    return this._services;
+  }
+  get_local_service(service_id, context) {
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(service_id);
+    const [ws, client_id] = context["to"].split("/");
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+      client_id === this._client_id,
+      "Services can only be accessed locally",
+    );
+
+    const service = this._services[service_id];
+    if (!service) {
+      throw new Error("Service not found: " + service_id);
+    }
+
+    service.config["workspace"] = ws;
+    // allow access for the same workspace
+    if (service.config.visibility == "public") {
+      return service;
+    }
+
+    // allow access for the same workspace
+    if (context["ws"] === ws) {
+      return service;
+    }
+
+    throw new Error(
+      `Permission denied for protected service: ${service_id}, workspace mismatch: ${ws} != ${context["ws"]}`,
+    );
+  }
+  async get_remote_service(service_uri, timeout) {
+    timeout = timeout === undefined ? this._method_timeout : timeout;
+    if (!service_uri && this.manager_id) {
+      service_uri = "*/" + this.manager_id;
+    } else if (!service_uri.includes(":")) {
+      service_uri = this._client_id + ":" + service_uri;
+    }
+    const provider = service_uri.split(":")[0];
+    let service_id = service_uri.split(":")[1];
+    if (service_id.includes("@")) {
+      service_id = service_id.split("@")[0];
+      const app_id = service_uri.split("@")[1];
+      if (this._app_id)
+        (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+          app_id === this._app_id,
+          `Invalid app id: ${app_id} != ${this._app_id}`,
+        );
+    }
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(provider, `Invalid service uri: ${service_uri}`);
+
+    try {
+      const method = this._generate_remote_method({
+        _rtarget: provider,
+        _rmethod: "services.built-in.get_service",
+        _rpromise: true,
+        _rdoc: "Get a remote service",
+        _rsig: "get_service(service_id)",
+      });
+      const svc = await (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.waitFor)(
+        method(service_id),
+        timeout,
+        "Timeout Error: Failed to get remote service: " + service_uri,
+      );
+      svc.id = `${provider}:${service_id}`;
+      return svc;
+    } catch (e) {
+      console.error("Failed to get remote service: " + service_uri, e);
+      throw e;
+    }
+  }
+  _annotate_service_methods(
+    aObject,
+    object_id,
+    require_context,
+    run_in_executor,
+    visibility,
+  ) {
+    if (typeof aObject === "function") {
+      // mark the method as a remote method that requires context
+      let method_name = object_id.split(".")[1];
+      this._method_annotations.set(aObject, {
+        require_context: Array.isArray(require_context)
+          ? require_context.includes(method_name)
+          : !!require_context,
+        run_in_executor: run_in_executor,
+        method_id: "services." + object_id,
+        visibility: visibility,
+      });
+    } else if (aObject instanceof Array || aObject instanceof Object) {
+      for (let key of Object.keys(aObject)) {
+        let val = aObject[key];
+        if (typeof val === "function" && val.__rpc_object__) {
+          let client_id = val.__rpc_object__._rtarget;
+          if (client_id.includes("/")) {
+            client_id = client_id.split("/")[1];
+          }
+          if (this._client_id === client_id) {
+            if (aObject instanceof Array) {
+              aObject = aObject.slice();
+            }
+            // recover local method
+            aObject[key] = indexObject(
+              this._object_store,
+              val.__rpc_object__._rmethod,
+            );
+            val = aObject[key]; // make sure it's annotated later
+          } else {
+            throw new Error(
+              `Local method not found: ${val.__rpc_object__._rmethod}, client id mismatch ${this._client_id} != ${client_id}`,
+            );
+          }
+        }
+        this._annotate_service_methods(
+          val,
+          object_id + "." + key,
+          require_context,
+          run_in_executor,
+          visibility,
+        );
+      }
+    }
+  }
+  add_service(api, overwrite) {
+    if (!api || Array.isArray(api)) throw new Error("Invalid service object");
+    if (api.constructor === Object) {
+      api = Object.assign({}, api);
+    } else {
+      const normApi = {};
+      const props = Object.getOwnPropertyNames(api).concat(
+        Object.getOwnPropertyNames(Object.getPrototypeOf(api)),
+      );
+      for (let k of props) {
+        if (k !== "constructor") {
+          if (typeof api[k] === "function") normApi[k] = api[k].bind(api);
+          else normApi[k] = api[k];
+        }
+      }
+      // For class instance, we need set a default id
+      api.id = api.id || "default";
+      api = normApi;
+    }
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+      api.id && typeof api.id === "string",
+      `Service id not found: ${api}`,
+    );
+    if (!api.name) {
+      api.name = api.id;
+    }
+    if (!api.config) {
+      api.config = {};
+    }
+    if (!api.type) {
+      api.type = "generic";
+    }
+    // require_context only applies to the top-level functions
+    let require_context = false,
+      run_in_executor = false;
+    if (api.config.require_context)
+      require_context = api.config.require_context;
+    if (api.config.run_in_executor) run_in_executor = true;
+    const visibility = api.config.visibility || "protected";
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(["protected", "public"].includes(visibility));
+    this._annotate_service_methods(
+      api,
+      api["id"],
+      require_context,
+      run_in_executor,
+      visibility,
+    );
+
+    if (this._services[api.id]) {
+      if (overwrite) {
+        delete this._services[api.id];
+      } else {
+        throw new Error(
+          `Service already exists: ${api.id}, please specify a different id (not ${api.id}) or overwrite=true`,
+        );
+      }
+    }
+    this._services[api.id] = api;
+    return api;
+  }
+
+  _extract_service_info(service) {
+    return {
+      id: `${this._client_id}:${service["id"]}`,
+      type: service["type"],
+      name: service["name"],
+      description: service["description"] || "",
+      config: service["config"],
+      app_id: this._app_id,
+    };
+  }
+
+  async register_service(api, overwrite, notify, context) {
+    if (notify === undefined) notify = true;
+    if (context) {
+      // If this function is called from remote, we need to make sure
+      const [workspace, client_id] = context["to"].split("/");
+      (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(client_id === this._client_id);
+      (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+        workspace === context["ws"],
+        "Services can only be registered from the same workspace",
+      );
+    }
+    const service = this.add_service(api, overwrite);
+    const serviceInfo = this._extract_service_info(service);
+    if (notify) {
+      if (this.manager_id) {
+        this.emit({
+          type: "service-added",
+          to: "*/" + this.manager_id,
+          service: serviceInfo,
+        });
+      } else {
+        this.emit({ type: "service-added", to: "*", service: serviceInfo });
+      }
+    }
+    return serviceInfo;
+  }
+  async unregister_service(service, notify) {
+    if (service instanceof Object) {
+      service = service.id;
+    }
+    if (!this._services[service]) {
+      throw new Error(`Service not found: ${service}`);
+    }
+    const api = this._services[service];
+    delete this._services[service];
+    if (notify) {
+      const serviceInfo = this._extract_service_info(api);
+      if (this.manager_id) {
+        this.emit({
+          type: "service-removed",
+          to: "*/" + this.manager_id,
+          service: serviceInfo,
+        });
+      } else {
+        this.emit({ type: "service-removed", to: "*", service: serviceInfo });
+      }
+    }
+  }
+
+  _ndarray(typedArray, shape, dtype) {
+    const _dtype = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(typedArray);
+    if (dtype && dtype !== _dtype) {
+      throw (
+        "dtype doesn't match the type of the array: " + _dtype + " != " + dtype
+      );
+    }
+    shape = shape || [typedArray.length];
+    return {
+      _rtype: "ndarray",
+      _rvalue: typedArray.buffer,
+      _rshape: shape,
+      _rdtype: _dtype,
+    };
+  }
+
+  _encode_callback(
+    name,
+    callback,
+    session_id,
+    clear_after_called,
+    timer,
+    local_workspace,
+  ) {
+    let method_id = `${session_id}.${name}`;
+    let encoded = {
+      _rtype: "method",
+      _rtarget: local_workspace
+        ? `${local_workspace}/${this._client_id}`
+        : this._client_id,
+      _rmethod: method_id,
+      _rpromise: false,
+    };
+
+    const self = this;
+    let wrapped_callback = function () {
+      try {
+        callback.apply(null, Array.prototype.slice.call(arguments));
+      } catch (error) {
+        console.error("Error in callback:", method_id, error);
+      } finally {
+        if (clear_after_called && self._object_store[session_id]) {
+          // console.log("Deleting session", session_id, "from", self._client_id);
+          delete self._object_store[session_id];
+        }
+        if (timer && timer.started) {
+          timer.clear();
+        }
+      }
+    };
+
+    return [encoded, wrapped_callback];
+  }
+
+  async _encode_promise(
+    resolve,
+    reject,
+    session_id,
+    clear_after_called,
+    timer,
+    local_workspace,
+  ) {
+    let store = this._get_session_store(session_id, true);
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+      store,
+      `Failed to create session store ${session_id} due to invalid parent`,
+    );
+    let encoded = {};
+
+    if (timer && reject && this._method_timeout) {
+      encoded.heartbeat = await this._encode(
+        timer.reset.bind(timer),
+        session_id,
+        local_workspace,
+      );
+      encoded.interval = this._method_timeout / 2;
+      store.timer = timer;
+    } else {
+      timer = null;
+    }
+
+    [encoded.resolve, store.resolve] = this._encode_callback(
+      "resolve",
+      resolve,
+      session_id,
+      clear_after_called,
+      timer,
+      local_workspace,
+    );
+    [encoded.reject, store.reject] = this._encode_callback(
+      "reject",
+      reject,
+      session_id,
+      clear_after_called,
+      timer,
+      local_workspace,
+    );
+    return encoded;
+  }
+
+  async _send_chunks(data, target_id, session_id) {
+    let remote_services = await this.get_remote_service(
+      `${target_id}:built-in`,
+    );
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+      remote_services.message_cache,
+      "Remote client does not support message caching for long message.",
+    );
+    let message_cache = remote_services.message_cache;
+    let message_id = session_id || (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.randId)();
+    await message_cache.create(message_id, !!session_id);
+    let total_size = data.length;
+    let chunk_num = Math.ceil(total_size / CHUNK_SIZE);
+    for (let idx = 0; idx < chunk_num; idx++) {
+      let start_byte = idx * CHUNK_SIZE;
+      await message_cache.append(
+        message_id,
+        data.slice(start_byte, start_byte + CHUNK_SIZE),
+        !!session_id,
+      );
+      console.log(
+        `Sending chunk ${idx + 1}/${chunk_num} (${total_size} bytes)`,
+      );
+    }
+    // console.log(`All chunks sent (${chunk_num})`);
+    await message_cache.process(message_id, !!session_id);
+  }
+
+  emit(main_message, extra_data) {
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+      typeof main_message === "object" && main_message.type,
+      "Invalid message, must be an object with a type field.",
+    );
+    let message_package = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_2__.encode)(main_message);
+    if (extra_data) {
+      const extra = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_2__.encode)(extra_data);
+      message_package = new Uint8Array([...message_package, ...extra]);
+    }
+    const total_size = message_package.length;
+    if (total_size <= CHUNK_SIZE + 1024) {
+      return this._emit_message(message_package);
+    } else {
+      throw new Error("Message is too large to send in one go.");
+    }
+  }
+
+  _generate_remote_method(
+    encoded_method,
+    remote_parent,
+    local_parent,
+    remote_workspace,
+    local_workspace,
+  ) {
+    let target_id = encoded_method._rtarget;
+    if (remote_workspace && !target_id.includes("/")) {
+      if (remote_workspace !== target_id) {
+        target_id = remote_workspace + "/" + target_id;
+      }
+      // Fix the target id to be an absolute id
+      encoded_method._rtarget = target_id;
+    }
+    let method_id = encoded_method._rmethod;
+    let with_promise = encoded_method._rpromise;
+    const self = this;
+
+    function remote_method() {
+      return new Promise(async (resolve, reject) => {
+        let local_session_id = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.randId)();
+        if (local_parent) {
+          // Store the children session under the parent
+          local_session_id = local_parent + "." + local_session_id;
+        }
+        let store = self._get_session_store(local_session_id, true);
+        if (!store) {
+          reject(
+            new Error(
+              `Runtime Error: Failed to get session store ${local_session_id}`,
+            ),
+          );
+          return;
+        }
+        store["target_id"] = target_id;
+        const args = await self._encode(
+          Array.prototype.slice.call(arguments),
+          local_session_id,
+          local_workspace,
+        );
+        const argLength = args.length;
+        // if the last argument is an object, mark it as kwargs
+        const withKwargs =
+          argLength > 0 &&
+          typeof args[argLength - 1] === "object" &&
+          args[argLength - 1] !== null &&
+          args[argLength - 1]._rkwargs;
+        if (withKwargs) delete args[argLength - 1]._rkwargs;
+
+        let from_client;
+        if (!self._local_workspace) {
+          from_client = self._client_id;
+        } else {
+          from_client = self._local_workspace + "/" + self._client_id;
+        }
+
+        let main_message = {
+          type: "method",
+          from: from_client,
+          to: target_id,
+          method: method_id,
+        };
+        let extra_data = {};
+        if (args) {
+          extra_data["args"] = args;
+        }
+        if (withKwargs) {
+          extra_data["with_kwargs"] = withKwargs;
+        }
+
+        // console.log(
+        //   `Calling remote method ${target_id}:${method_id}, session: ${local_session_id}`
+        // );
+        if (remote_parent) {
+          // Set the parent session
+          // Note: It's a session id for the remote, not the current client
+          main_message["parent"] = remote_parent;
+        }
+
+        let timer = null;
+        if (with_promise) {
+          // Only pass the current session id to the remote
+          // if we want to received the result
+          // I.e. the session id won't be passed for promises themselves
+          main_message["session"] = local_session_id;
+          let method_name = `${target_id}:${method_id}`;
+          timer = new Timer(
+            self._method_timeout,
+            reject,
+            [`Method call time out: ${method_name}`],
+            method_name,
+          );
+          // By default, hypha will clear the session after the method is called
+          // However, if the args contains _rintf === true, we will not clear the session
+          let clear_after_called = true;
+          for (let arg of args) {
+            if (typeof arg === "object" && arg._rintf === true) {
+              clear_after_called = false;
+              break;
+            }
+          }
+          extra_data["promise"] = await self._encode_promise(
+            resolve,
+            reject,
+            local_session_id,
+            clear_after_called,
+            timer,
+            local_workspace,
+          );
+        }
+        // The message consists of two segments, the main message and extra data
+        let message_package = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_2__.encode)(main_message);
+        if (extra_data) {
+          const extra = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_2__.encode)(extra_data);
+          message_package = new Uint8Array([...message_package, ...extra]);
+        }
+        const total_size = message_package.length;
+        if (total_size <= CHUNK_SIZE + 1024) {
+          self._emit_message(message_package).then(function () {
+            if (timer) {
+              // console.log(`Start watchdog timer.`);
+              // Only start the timer after we send the message successfully
+              timer.start();
+            }
+          });
+        } else {
+          // send chunk by chunk
+          self
+            ._send_chunks(message_package, target_id, remote_parent)
+            .then(function () {
+              if (timer) {
+                // console.log(`Start watchdog timer.`);
+                // Only start the timer after we send the message successfully
+                timer.start();
+              }
+            })
+            .catch(function (err) {
+              console.error("Failed to send message", err);
+              reject(err);
+            });
+        }
+      });
+    }
+
+    // Generate debugging information for the method
+    remote_method.__rpc_object__ = encoded_method;
+    const parts = method_id.split(".");
+    remote_method.__name__ = parts[parts.length - 1];
+    remote_method.__doc__ = encoded_method._rdoc;
+    remote_method.__sig__ = encoded_method._rsig;
+    return remote_method;
+  }
+
+  get_client_info() {
+    const services = [];
+    for (let service of Object.values(this._services)) {
+      services.push(this._extract_service_info(service));
+    }
+
+    return {
+      id: this._client_id,
+      services: services,
+    };
+  }
+
+  async _handle_method(data) {
+    let reject = null;
+    let heartbeat_task = null;
+    try {
+      (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(data.method && data.ctx && data.from && data.ws);
+      const method_name = data.from + ":" + data.method;
+      const remote_workspace = data.from.split("/")[0];
+      // Make sure the target id is an absolute id
+      data["to"] = data["to"].includes("/")
+        ? data["to"]
+        : remote_workspace + "/" + data["to"];
+      data["ctx"]["to"] = data["to"];
+      let local_workspace;
+      if (!this._local_workspace) {
+        local_workspace = data["to"].split("/")[0];
+      } else {
+        if (this._local_workspace && this._local_workspace !== "*") {
+          (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+            data["to"].split("/")[0] === this._local_workspace,
+            "Workspace mismatch: " +
+              data["to"].split("/")[0] +
+              " != " +
+              this._local_workspace,
+          );
+        }
+        local_workspace = this._local_workspace;
+      }
+      const local_parent = data.parent;
+
+      let resolve, reject;
+      if (data.promise) {
+        // Decode the promise with the remote session id
+        // Such that the session id will be passed to the remote as a parent session id
+        const promise = await this._decode(
+          data.promise,
+          data.session,
+          local_parent,
+          remote_workspace,
+          local_workspace,
+        );
+        resolve = promise.resolve;
+        reject = promise.reject;
+        if (promise.heartbeat && promise.interval) {
+          async function heartbeat() {
+            try {
+              console.log("Reset heartbeat timer: " + data.method);
+              await promise.heartbeat();
+            } catch (err) {
+              console.error(err);
+            }
+          }
+          heartbeat_task = setInterval(heartbeat, promise.interval * 1000);
+        }
+      }
+
+      let method;
+
+      try {
+        method = indexObject(this._object_store, data["method"]);
+      } catch (e) {
+        console.debug("Failed to find method", method_name, this._client_id, e);
+        throw new Error(`Method not found: ${method_name} at ${this._client_id}`);
+      }
+
+      (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+        method && typeof method === "function",
+        "Invalid method: " + method_name,
+      );
+
+      // Check permission
+      if (this._method_annotations.has(method)) {
+        // For services, it should not be protected
+        if (this._method_annotations.get(method).visibility === "protected") {
+          if (local_workspace !== remote_workspace) {
+            throw new Error(
+              "Permission denied for protected method " +
+                method_name +
+                ", workspace mismatch: " +
+                local_workspace +
+                " != " +
+                remote_workspace,
+            );
+          }
+        }
+      } else {
+        // For sessions, the target_id should match exactly
+        let session_target_id =
+          this._object_store[data.method.split(".")[0]].target_id;
+        if (
+          local_workspace === remote_workspace &&
+          session_target_id &&
+          session_target_id.indexOf("/") === -1
+        ) {
+          session_target_id = local_workspace + "/" + session_target_id;
+        }
+        if (session_target_id !== data.from) {
+          throw new Error(
+            "Access denied for method call (" +
+              method_name +
+              ") from " +
+              data.from +
+              " to target " +
+              session_target_id,
+          );
+        }
+      }
+
+      // Make sure the parent session is still open
+      if (local_parent) {
+        // The parent session should be a session that generate the current method call
+        (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+          this._get_session_store(local_parent, true) !== null,
+          "Parent session was closed: " + local_parent,
+        );
+      }
+      let args;
+      if (data.args) {
+        args = await this._decode(
+          data.args,
+          data.session,
+          null,
+          remote_workspace,
+          null,
+        );
+      } else {
+        args = [];
+      }
+      if (
+        this._method_annotations.has(method) &&
+        this._method_annotations.get(method).require_context
+      ) {
+        args.push(data.ctx);
+      }
+      // console.log("Executing method: " + method_name);
+      if (data.promise) {
+        const result = method.apply(null, args);
+        if (result instanceof Promise) {
+          result
+            .then((result) => {
+              resolve(result);
+              clearInterval(heartbeat_task);
+            })
+            .catch((err) => {
+              reject(err);
+              clearInterval(heartbeat_task);
+            });
+        } else {
+          resolve(result);
+          clearInterval(heartbeat_task);
+        }
+      } else {
+        method.apply(null, args);
+        clearInterval(heartbeat_task);
+      }
+    } catch (err) {
+      if (reject) {
+        reject(err);
+        console.debug("Error during calling method: ", err);
+      } else {
+        console.error("Error during calling method: ", err);
+      }
+      // make sure we clear the heartbeat timer
+      clearInterval(heartbeat_task);
+    }
+  }
+
+  encode(aObject, session_id) {
+    return this._encode(aObject, session_id);
+  }
+
+  _get_session_store(session_id, create) {
+    let store = this._object_store;
+    const levels = session_id.split(".");
+    if (create) {
+      const last_index = levels.length - 1;
+      for (let level of levels.slice(0, last_index)) {
+        if (!store[level]) {
+          return null;
+        }
+        store = store[level];
+      }
+      // Create the last level
+      if (!store[levels[last_index]]) {
+        store[levels[last_index]] = {};
+      }
+      return store[levels[last_index]];
+    } else {
+      for (let level of levels) {
+        if (!store[level]) {
+          return null;
+        }
+        store = store[level];
+      }
+      return store;
+    }
+  }
+
+  /**
+   * Prepares the provided set of remote method arguments for
+   * sending to the remote site, replaces all the callbacks with
+   * identifiers
+   *
+   * @param {Array} args to wrap
+   *
+   * @returns {Array} wrapped arguments
+   */
+  async _encode(aObject, session_id, local_workspace) {
+    const aType = typeof aObject;
+    if (
+      aType === "number" ||
+      aType === "string" ||
+      aType === "boolean" ||
+      aObject === null ||
+      aObject === undefined ||
+      aObject instanceof Uint8Array
+    ) {
+      return aObject;
+    }
+    if (aObject instanceof ArrayBuffer) {
+      return {
+        _rtype: "memoryview",
+        _rvalue: new Uint8Array(aObject),
+      };
+    }
+    // Reuse the remote object
+    if (aObject.__rpc_object__) {
+      return aObject.__rpc_object__;
+    }
+
+    let bObject;
+
+    // skip if already encoded
+    if (aObject.constructor instanceof Object && aObject._rtype) {
+      // make sure the interface functions are encoded
+      const temp = aObject._rtype;
+      delete aObject._rtype;
+      bObject = await this._encode(aObject, session_id, local_workspace);
+      bObject._rtype = temp;
+      return bObject;
+    }
+
+    if (typeof aObject === "function") {
+      if (this._method_annotations.has(aObject)) {
+        let annotation = this._method_annotations.get(aObject);
+        bObject = {
+          _rtype: "method",
+          _rtarget: this._client_id,
+          _rmethod: annotation.method_id,
+          _rpromise: true,
+        };
+      } else {
+        (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(typeof session_id === "string");
+        let object_id;
+        if (aObject.__name__) {
+          object_id = `${(0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.randId)()}-${aObject.__name__}`;
+        } else {
+          object_id = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.randId)();
+        }
+        bObject = {
+          _rtype: "method",
+          _rtarget: this._client_id,
+          _rmethod: `${session_id}.${object_id}`,
+          _rpromise: true,
+        };
+        let store = this._get_session_store(session_id, true);
+        (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+          store !== null,
+          `Failed to create session store ${session_id} due to invalid parent`,
+        );
+        store[object_id] = aObject;
+      }
+      bObject._rdoc = aObject.__doc__;
+      bObject._rsig = aObject.__sig__;
+      if (!bObject._rdoc || !bObject._rsig) {
+        try {
+          const funcInfo = getFunctionInfo(aObject);
+          if (funcInfo && !bObject._rdoc) {
+            bObject._rdoc = `${funcInfo.doc}`;
+          }
+          if (funcInfo && !bObject._rsig) {
+            bObject._rsig = `${funcInfo.name}(${funcInfo.sig})`;
+          }
+        } catch (e) {
+          console.error("Failed to extract function docstring:", aObject);
+        }
+      }
+
+      return bObject;
+    }
+    const isarray = Array.isArray(aObject);
+
+    for (let tp of Object.keys(this._codecs)) {
+      const codec = this._codecs[tp];
+      if (codec.encoder && aObject instanceof codec.type) {
+        // TODO: what if multiple encoders found
+        let encodedObj = await Promise.resolve(codec.encoder(aObject));
+        if (encodedObj && !encodedObj._rtype) encodedObj._rtype = codec.name;
+        // encode the functions in the interface object
+        if (typeof encodedObj === "object") {
+          const temp = encodedObj._rtype;
+          delete encodedObj._rtype;
+          encodedObj = await this._encode(
+            encodedObj,
+            session_id,
+            local_workspace,
+          );
+          encodedObj._rtype = temp;
+        }
+        bObject = encodedObj;
+        return bObject;
+      }
+    }
+
+    if (
+      /*global tf*/
+      typeof tf !== "undefined" &&
+      tf.Tensor &&
+      aObject instanceof tf.Tensor
+    ) {
+      const v_buffer = aObject.dataSync();
+      bObject = {
+        _rtype: "ndarray",
+        _rvalue: new Uint8Array(v_buffer.buffer),
+        _rshape: aObject.shape,
+        _rdtype: aObject.dtype,
+      };
+    } else if (
+      /*global nj*/
+      typeof nj !== "undefined" &&
+      nj.NdArray &&
+      aObject instanceof nj.NdArray
+    ) {
+      const dtype = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(aObject.selection.data);
+      bObject = {
+        _rtype: "ndarray",
+        _rvalue: new Uint8Array(aObject.selection.data.buffer),
+        _rshape: aObject.shape,
+        _rdtype: dtype,
+      };
+    } else if (aObject instanceof Error) {
+      console.error(aObject);
+      bObject = {
+        _rtype: "error",
+        _rvalue: aObject.toString(),
+        _rtrace: aObject.stack,
+      };
+    }
+    // send objects supported by structure clone algorithm
+    // https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
+    else if (
+      aObject !== Object(aObject) ||
+      aObject instanceof Boolean ||
+      aObject instanceof String ||
+      aObject instanceof Date ||
+      aObject instanceof RegExp ||
+      aObject instanceof ImageData ||
+      (typeof FileList !== "undefined" && aObject instanceof FileList) ||
+      (typeof FileSystemDirectoryHandle !== "undefined" &&
+        aObject instanceof FileSystemDirectoryHandle) ||
+      (typeof FileSystemFileHandle !== "undefined" &&
+        aObject instanceof FileSystemFileHandle) ||
+      (typeof FileSystemHandle !== "undefined" &&
+        aObject instanceof FileSystemHandle) ||
+      (typeof FileSystemWritableFileStream !== "undefined" &&
+        aObject instanceof FileSystemWritableFileStream)
+    ) {
+      bObject = aObject;
+      // TODO: avoid object such as DynamicPlugin instance.
+    } else if (aObject instanceof Blob) {
+      let _current_pos = 0;
+      async function read(length) {
+        let blob;
+        if (length) {
+          blob = aObject.slice(_current_pos, _current_pos + length);
+        } else {
+          blob = aObject.slice(_current_pos);
+        }
+        const ret = new Uint8Array(await blob.arrayBuffer());
+        _current_pos = _current_pos + ret.byteLength;
+        return ret;
+      }
+      function seek(pos) {
+        _current_pos = pos;
+      }
+      bObject = {
+        _rtype: "iostream",
+        _rnative: "js:blob",
+        type: aObject.type,
+        name: aObject.name,
+        size: aObject.size,
+        path: aObject._path || aObject.webkitRelativePath,
+        read: await this._encode(read, session_id, local_workspace),
+        seek: await this._encode(seek, session_id, local_workspace),
+      };
+    } else if (aObject instanceof ArrayBufferView) {
+      const dtype = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(aObject);
+      bObject = {
+        _rtype: "typedarray",
+        _rvalue: new Uint8Array(aObject.buffer),
+        _rdtype: dtype,
+      };
+    } else if (aObject instanceof DataView) {
+      bObject = {
+        _rtype: "memoryview",
+        _rvalue: new Uint8Array(aObject.buffer),
+      };
+    } else if (aObject instanceof Set) {
+      bObject = {
+        _rtype: "set",
+        _rvalue: await this._encode(
+          Array.from(aObject),
+          session_id,
+          local_workspace,
+        ),
+      };
+    } else if (aObject instanceof Map) {
+      bObject = {
+        _rtype: "orderedmap",
+        _rvalue: await this._encode(
+          Array.from(aObject),
+          session_id,
+          local_workspace,
+        ),
+      };
+    } else if (
+      aObject.constructor instanceof Object ||
+      Array.isArray(aObject)
+    ) {
+      bObject = isarray ? [] : {};
+      const keys = Object.keys(aObject);
+      for (let k of keys) {
+        bObject[k] = await this._encode(
+          aObject[k],
+          session_id,
+          local_workspace,
+        );
+      }
+    } else {
+      throw `hypha-rpc: Unsupported data type: ${aObject}, you can register a custom codec to encode/decode the object.`;
+    }
+
+    if (!bObject) {
+      throw new Error("Failed to encode object");
+    }
+    return bObject;
+  }
+
+  async decode(aObject) {
+    return await this._decode(aObject);
+  }
+
+  async _decode(
+    aObject,
+    remote_parent,
+    local_parent,
+    remote_workspace,
+    local_workspace,
+  ) {
+    if (!aObject) {
+      return aObject;
+    }
+    let bObject;
+    if (aObject._rtype) {
+      if (
+        this._codecs[aObject._rtype] &&
+        this._codecs[aObject._rtype].decoder
+      ) {
+        const temp = aObject._rtype;
+        delete aObject._rtype;
+        aObject = await this._decode(
+          aObject,
+          remote_parent,
+          local_parent,
+          remote_workspace,
+          local_workspace,
+        );
+        aObject._rtype = temp;
+
+        bObject = await Promise.resolve(
+          this._codecs[aObject._rtype].decoder(aObject),
+        );
+      } else if (aObject._rtype === "method") {
+        bObject = this._generate_remote_method(
+          aObject,
+          remote_parent,
+          local_parent,
+          remote_workspace,
+          local_workspace,
+        );
+      } else if (aObject._rtype === "ndarray") {
+        /*global nj tf*/
+        //create build array/tensor if used in the plugin
+        if (typeof nj !== "undefined" && nj.array) {
+          if (Array.isArray(aObject._rvalue)) {
+            aObject._rvalue = aObject._rvalue.reduce(_appendBuffer);
+          }
+          bObject = nj
+            .array(new Uint8(aObject._rvalue), aObject._rdtype)
+            .reshape(aObject._rshape);
+        } else if (typeof tf !== "undefined" && tf.Tensor) {
+          if (Array.isArray(aObject._rvalue)) {
+            aObject._rvalue = aObject._rvalue.reduce(_appendBuffer);
+          }
+          const arraytype = _utils_js__WEBPACK_IMPORTED_MODULE_0__.dtypeToTypedArray[aObject._rdtype];
+          bObject = tf.tensor(
+            new arraytype(aObject._rvalue),
+            aObject._rshape,
+            aObject._rdtype,
+          );
+        } else {
+          //keep it as regular if transfered to the main app
+          bObject = aObject;
+        }
+      } else if (aObject._rtype === "error") {
+        bObject = new Error(
+          "RemoteError: " + aObject._rvalue + "\n" + (aObject._rtrace || ""),
+        );
+      } else if (aObject._rtype === "typedarray") {
+        const arraytype = _utils_js__WEBPACK_IMPORTED_MODULE_0__.dtypeToTypedArray[aObject._rdtype];
+        if (!arraytype)
+          throw new Error("unsupported dtype: " + aObject._rdtype);
+        const buffer = aObject._rvalue.buffer.slice(
+          aObject._rvalue.byteOffset,
+          aObject._rvalue.byteOffset + aObject._rvalue.byteLength,
+        );
+        bObject = new arraytype(buffer);
+      } else if (aObject._rtype === "memoryview") {
+        bObject = aObject._rvalue.buffer.slice(
+          aObject._rvalue.byteOffset,
+          aObject._rvalue.byteOffset + aObject._rvalue.byteLength,
+        ); // ArrayBuffer
+      } else if (aObject._rtype === "iostream") {
+        if (aObject._rnative === "js:blob") {
+          const read = await this._generate_remote_method(
+            aObject.read,
+            remote_parent,
+            local_parent,
+            remote_workspace,
+            local_workspace,
+          );
+          const bytes = await read();
+          bObject = new Blob([bytes], {
+            type: aObject.type,
+            name: aObject.name,
+          });
+        } else {
+          bObject = {};
+          for (let k of Object.keys(aObject)) {
+            if (!k.startsWith("_")) {
+              bObject[k] = await this._decode(
+                aObject[k],
+                remote_parent,
+                local_parent,
+                remote_workspace,
+                local_workspace,
+              );
+            }
+          }
+        }
+        bObject["__rpc_object__"] = aObject;
+      } else if (aObject._rtype === "orderedmap") {
+        bObject = new Map(
+          await this._decode(
+            aObject._rvalue,
+            remote_parent,
+            local_parent,
+            remote_workspace,
+            local_workspace,
+          ),
+        );
+      } else if (aObject._rtype === "set") {
+        bObject = new Set(
+          await this._decode(
+            aObject._rvalue,
+            remote_parent,
+            local_parent,
+            remote_workspace,
+            local_workspace,
+          ),
+        );
+      } else {
+        const temp = aObject._rtype;
+        delete aObject._rtype;
+        bObject = await this._decode(
+          aObject,
+          remote_parent,
+          local_parent,
+          remote_workspace,
+          local_workspace,
+        );
+        bObject._rtype = temp;
+      }
+    } else if (aObject.constructor === Object || Array.isArray(aObject)) {
+      const isarray = Array.isArray(aObject);
+      bObject = isarray ? [] : {};
+      for (let k of Object.keys(aObject)) {
+        if (isarray || aObject.hasOwnProperty(k)) {
+          const v = aObject[k];
+          bObject[k] = await this._decode(
+            v,
+            remote_parent,
+            local_parent,
+            remote_workspace,
+            local_workspace,
+          );
+        }
+      }
+    } else {
+      bObject = aObject;
+    }
+    if (bObject === undefined) {
+      throw new Error("Failed to decode object");
+    }
+    return bObject;
+  }
+}
+
+
+/***/ }),
+
+/***/ "./src/utils.js":
+/*!**********************!*\
+  !*** ./src/utils.js ***!
+  \**********************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   MessageEmitter: () => (/* binding */ MessageEmitter),
+/* harmony export */   assert: () => (/* binding */ assert),
+/* harmony export */   cacheRequirements: () => (/* binding */ cacheRequirements),
+/* harmony export */   dtypeToTypedArray: () => (/* binding */ dtypeToTypedArray),
+/* harmony export */   loadRequirements: () => (/* binding */ loadRequirements),
+/* harmony export */   loadRequirementsInWebworker: () => (/* binding */ loadRequirementsInWebworker),
+/* harmony export */   loadRequirementsInWindow: () => (/* binding */ loadRequirementsInWindow),
+/* harmony export */   normalizeConfig: () => (/* binding */ normalizeConfig),
+/* harmony export */   randId: () => (/* binding */ randId),
+/* harmony export */   typedArrayToDtype: () => (/* binding */ typedArrayToDtype),
+/* harmony export */   typedArrayToDtypeMapping: () => (/* binding */ typedArrayToDtypeMapping),
+/* harmony export */   urlJoin: () => (/* binding */ urlJoin),
+/* harmony export */   waitFor: () => (/* binding */ waitFor)
+/* harmony export */ });
+function randId() {
+  return Math.random().toString(36).substr(2, 10) + new Date().getTime();
+}
+
+const dtypeToTypedArray = {
+  int8: Int8Array,
+  int16: Int16Array,
+  int32: Int32Array,
+  uint8: Uint8Array,
+  uint16: Uint16Array,
+  uint32: Uint32Array,
+  float32: Float32Array,
+  float64: Float64Array,
+  array: Array,
+};
+
+async function loadRequirementsInWindow(requirements) {
+  function _importScript(url) {
+    //url is URL of external file, implementationCode is the code
+    //to be called from the file, location is the location to
+    //insert the <script> element
+    return new Promise((resolve, reject) => {
+      var scriptTag = document.createElement("script");
+      scriptTag.src = url;
+      scriptTag.type = "text/javascript";
+      scriptTag.onload = resolve;
+      scriptTag.onreadystatechange = function () {
+        if (this.readyState === "loaded" || this.readyState === "complete") {
+          resolve();
+        }
+      };
+      scriptTag.onerror = reject;
+      document.head.appendChild(scriptTag);
+    });
+  }
+
+  // support importScripts outside web worker
+  async function importScripts() {
+    var args = Array.prototype.slice.call(arguments),
+      len = args.length,
+      i = 0;
+    for (; i < len; i++) {
+      await _importScript(args[i]);
+    }
+  }
+
+  if (
+    requirements &&
+    (Array.isArray(requirements) || typeof requirements === "string")
+  ) {
+    try {
+      var link_node;
+      requirements =
+        typeof requirements === "string" ? [requirements] : requirements;
+      if (Array.isArray(requirements)) {
+        for (var i = 0; i < requirements.length; i++) {
+          if (
+            requirements[i].toLowerCase().endsWith(".css") ||
+            requirements[i].startsWith("css:")
+          ) {
+            if (requirements[i].startsWith("css:")) {
+              requirements[i] = requirements[i].slice(4);
+            }
+            link_node = document.createElement("link");
+            link_node.rel = "stylesheet";
+            link_node.href = requirements[i];
+            document.head.appendChild(link_node);
+          } else if (
+            requirements[i].toLowerCase().endsWith(".mjs") ||
+            requirements[i].startsWith("mjs:")
+          ) {
+            // import esmodule
+            if (requirements[i].startsWith("mjs:")) {
+              requirements[i] = requirements[i].slice(4);
+            }
+            await import(/* webpackIgnore: true */ requirements[i]);
+          } else if (
+            requirements[i].toLowerCase().endsWith(".js") ||
+            requirements[i].startsWith("js:")
+          ) {
+            if (requirements[i].startsWith("js:")) {
+              requirements[i] = requirements[i].slice(3);
+            }
+            await importScripts(requirements[i]);
+          } else if (requirements[i].startsWith("http")) {
+            await importScripts(requirements[i]);
+          } else if (requirements[i].startsWith("cache:")) {
+            //ignore cache
+          } else {
+            console.log("Unprocessed requirements url: " + requirements[i]);
+          }
+        }
+      } else {
+        throw "unsupported requirements definition";
+      }
+    } catch (e) {
+      throw "failed to import required scripts: " + requirements.toString();
+    }
+  }
+}
+
+async function loadRequirementsInWebworker(requirements) {
+  if (
+    requirements &&
+    (Array.isArray(requirements) || typeof requirements === "string")
+  ) {
+    try {
+      if (!Array.isArray(requirements)) {
+        requirements = [requirements];
+      }
+      for (var i = 0; i < requirements.length; i++) {
+        if (
+          requirements[i].toLowerCase().endsWith(".css") ||
+          requirements[i].startsWith("css:")
+        ) {
+          throw "unable to import css in a webworker";
+        } else if (
+          requirements[i].toLowerCase().endsWith(".js") ||
+          requirements[i].startsWith("js:")
+        ) {
+          if (requirements[i].startsWith("js:")) {
+            requirements[i] = requirements[i].slice(3);
+          }
+          importScripts(requirements[i]);
+        } else if (requirements[i].startsWith("http")) {
+          importScripts(requirements[i]);
+        } else if (requirements[i].startsWith("cache:")) {
+          //ignore cache
+        } else {
+          console.log("Unprocessed requirements url: " + requirements[i]);
+        }
+      }
+    } catch (e) {
+      throw "failed to import required scripts: " + requirements.toString();
+    }
+  }
+}
+
+function loadRequirements(requirements) {
+  if (
+    typeof WorkerGlobalScope !== "undefined" &&
+    self instanceof WorkerGlobalScope
+  ) {
+    return loadRequirementsInWebworker(requirements);
+  } else {
+    return loadRequirementsInWindow(requirements);
+  }
+}
+
+function normalizeConfig(config) {
+  config.version = config.version || "0.1.0";
+  config.description =
+    config.description || `[TODO: add description for ${config.name} ]`;
+  config.type = config.type || "rpc-window";
+  config.id = config.id || randId();
+  config.target_origin = config.target_origin || "*";
+  config.allow_execution = config.allow_execution || false;
+  // remove functions
+  config = Object.keys(config).reduce((p, c) => {
+    if (typeof config[c] !== "function") p[c] = config[c];
+    return p;
+  }, {});
+  return config;
+}
+const typedArrayToDtypeMapping = {
+  Int8Array: "int8",
+  Int16Array: "int16",
+  Int32Array: "int32",
+  Uint8Array: "uint8",
+  Uint16Array: "uint16",
+  Uint32Array: "uint32",
+  Float32Array: "float32",
+  Float64Array: "float64",
+  Array: "array",
+};
+
+const typedArrayToDtypeKeys = [];
+for (const arrType of Object.keys(typedArrayToDtypeMapping)) {
+  typedArrayToDtypeKeys.push(eval(arrType));
+}
+
+function typedArrayToDtype(obj) {
+  let dtype = typedArrayToDtypeMapping[obj.constructor.name];
+  if (!dtype) {
+    const pt = Object.getPrototypeOf(obj);
+    for (const arrType of typedArrayToDtypeKeys) {
+      if (pt instanceof arrType) {
+        dtype = typedArrayToDtypeMapping[arrType.name];
+        break;
+      }
+    }
+  }
+  return dtype;
+}
+
+function cacheUrlInServiceWorker(url) {
+  return new Promise(function (resolve, reject) {
+    const message = {
+      command: "add",
+      url: url,
+    };
+    if (!navigator.serviceWorker || !navigator.serviceWorker.register) {
+      reject("Service worker is not supported.");
+      return;
+    }
+    const messageChannel = new MessageChannel();
+    messageChannel.port1.onmessage = function (event) {
+      if (event.data && event.data.error) {
+        reject(event.data.error);
+      } else {
+        resolve(event.data && event.data.result);
+      }
+    };
+
+    if (navigator.serviceWorker && navigator.serviceWorker.controller) {
+      navigator.serviceWorker.controller.postMessage(message, [
+        messageChannel.port2,
+      ]);
+    } else {
+      reject("Service worker controller is not available");
+    }
+  });
+}
+
+async function cacheRequirements(requirements) {
+  requirements = requirements || [];
+  if (!Array.isArray(requirements)) {
+    requirements = [requirements];
+  }
+  for (let req of requirements) {
+    //remove prefix
+    if (req.startsWith("js:")) req = req.slice(3);
+    if (req.startsWith("css:")) req = req.slice(4);
+    if (req.startsWith("cache:")) req = req.slice(6);
+    if (!req.startsWith("http")) continue;
+
+    await cacheUrlInServiceWorker(req).catch((e) => {
+      console.error(e);
+    });
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assertion failed");
+  }
+}
+
+//#Source https://bit.ly/2neWfJ2
+function urlJoin(...args) {
+  return args
+    .join("/")
+    .replace(/[\/]+/g, "/")
+    .replace(/^(.+):\//, "$1://")
+    .replace(/^file:/, "file:/")
+    .replace(/\/(\?|&|#[^!])/g, "$1")
+    .replace(/\?/g, "&")
+    .replace("&", "?");
+}
+
+function waitFor(prom, time, error) {
+  let timer;
+  return Promise.race([
+    prom,
+    new Promise(
+      (_r, rej) =>
+        (timer = setTimeout(() => {
+          rej(error || "Timeout Error");
+        }, time * 1000)),
+    ),
+  ]).finally(() => clearTimeout(timer));
+}
+
+class MessageEmitter {
+  constructor(debug) {
+    this._event_handlers = {};
+    this._once_handlers = {};
+    this._debug = debug;
+  }
+  emit() {
+    throw new Error("emit is not implemented");
+  }
+  on(event, handler) {
+    if (!this._event_handlers[event]) {
+      this._event_handlers[event] = [];
+    }
+    this._event_handlers[event].push(handler);
+  }
+  once(event, handler) {
+    handler.___event_run_once = true;
+    this.on(event, handler);
+  }
+  off(event, handler) {
+    if (!event && !handler) {
+      // remove all events handlers
+      this._event_handlers = {};
+    } else if (event && !handler) {
+      // remove all hanlders for the event
+      if (this._event_handlers[event]) this._event_handlers[event] = [];
+    } else {
+      // remove a specific handler
+      if (this._event_handlers[event]) {
+        const idx = this._event_handlers[event].indexOf(handler);
+        if (idx >= 0) {
+          this._event_handlers[event].splice(idx, 1);
+        }
+      }
+    }
+  }
+  _fire(event, data) {
+    if (this._event_handlers[event]) {
+      var i = this._event_handlers[event].length;
+      while (i--) {
+        const handler = this._event_handlers[event][i];
+        try {
+          handler(data);
+        } catch (e) {
+          console.error(e);
+        } finally {
+          if (handler.___event_run_once) {
+            this._event_handlers[event].splice(i, 1);
+          }
+        }
+      }
+    } else {
+      if (this._debug) {
+        console.warn("unhandled event", event, data);
+      }
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ "./src/webrtc-client.js":
+/*!******************************!*\
+  !*** ./src/webrtc-client.js ***!
+  \******************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getRTCService: () => (/* binding */ getRTCService),
+/* harmony export */   registerRTCService: () => (/* binding */ registerRTCService)
+/* harmony export */ });
+/* harmony import */ var _rpc_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./rpc.js */ "./src/rpc.js");
+/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils.js */ "./src/utils.js");
+
+
+
+class WebRTCConnection {
+  constructor(channel) {
+    this._data_channel = channel;
+    this._handle_message = null;
+    this._reconnection_token = null;
+    this._data_channel.onmessage = async (event) => {
+      let data = event.data;
+      if (data instanceof Blob) {
+        data = await data.arrayBuffer();
+      }
+      this._handle_message(data);
+    };
+    const self = this;
+    this._data_channel.onclose = function () {
+      console.log("websocket closed");
+      self._data_channel = null;
+    };
+  }
+
+  on_message(handler) {
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(handler, "handler is required");
+    this._handle_message = handler;
+  }
+
+  async emit_message(data) {
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(this._handle_message, "No handler for message");
+    try {
+      this._data_channel.send(data);
+    } catch (exp) {
+      //   data = msgpack_unpackb(data);
+      console.error(`Failed to send data, error: ${exp}`);
+      throw exp;
+    }
+  }
+
+  async disconnect(reason) {
+    this._data_channel = null;
+    console.info(`data channel connection disconnected (${reason})`);
+  }
+}
+
+async function _setupRPC(config) {
+  (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(config.channel, "No channel provided");
+  (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(config.workspace, "No workspace provided");
+  const channel = config.channel;
+  const clientId = config.client_id || (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.randId)();
+  const connection = new WebRTCConnection(channel);
+  config.context = config.context || {};
+  config.context.connection_type = "webrtc";
+  const rpc = new _rpc_js__WEBPACK_IMPORTED_MODULE_0__.RPC(connection, {
+    client_id: clientId,
+    manager_id: null,
+    default_context: config.context,
+    name: config.name,
+    method_timeout: config.method_timeout || 10.0,
+    workspace: config.workspace,
+  });
+  return rpc;
+}
+
+async function _createOffer(params, server, config, onInit, context) {
+  config = config || {};
+  let offer = new RTCSessionDescription({
+    sdp: params.sdp,
+    type: params.type,
+  });
+
+  let pc = new RTCPeerConnection({
+    iceServers: config.ice_servers || [
+      { urls: ["stun:stun.l.google.com:19302"] },
+    ],
+    sdpSemantics: "unified-plan",
+  });
+
+  if (server) {
+    pc.addEventListener("datachannel", async (event) => {
+      const channel = event.channel;
+      let ctx = null;
+      if (context && context.user) ctx = { user: context.user };
+      const rpc = await _setupRPC({
+        channel: channel,
+        client_id: channel.label,
+        workspace: server.config.workspace,
+        context: ctx,
+      });
+      // Map all the local services to the webrtc client
+      rpc._services = server.rpc._services;
+    });
+  }
+
+  if (onInit) {
+    await onInit(pc);
+  }
+
+  await pc.setRemoteDescription(offer);
+
+  let answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+
+  return {
+    sdp: pc.localDescription.sdp,
+    type: pc.localDescription.type,
+    workspace: server.config.workspace,
+  };
+}
+
+async function getRTCService(server, service_id, config) {
+  config = config || {};
+  config.peer_id = config.peer_id || (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.randId)();
+
+  const pc = new RTCPeerConnection({
+    iceServers: config.ice_servers || [
+      { urls: ["stun:stun.l.google.com:19302"] },
+    ],
+    sdpSemantics: "unified-plan",
+  });
+
+  return new Promise(async (resolve, reject) => {
+    try {
+      pc.addEventListener(
+        "connectionstatechange",
+        () => {
+          if (pc.connectionState === "failed") {
+            pc.close();
+            reject(new Error("Connection failed"));
+          }
+        },
+        false,
+      );
+
+      if (config.on_init) {
+        await config.on_init(pc);
+        delete config.on_init;
+      }
+      let channel = pc.createDataChannel(config.peer_id, { ordered: true });
+      channel.binaryType = "arraybuffer";
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      const svc = await server.getService(service_id);
+      const answer = await svc.offer({
+        sdp: pc.localDescription.sdp,
+        type: pc.localDescription.type,
+      });
+
+      channel.onopen = () => {
+        config.channel = channel;
+        config.workspace = answer.workspace;
+        // Wait for the channel to be open before returning the rpc
+        // This is needed for safari to work
+        setTimeout(async () => {
+          const rpc = await _setupRPC(config);
+          pc.rpc = rpc;
+          async function getService(name) {
+            return await rpc.get_remote_service(config.peer_id + ":" + name);
+          }
+          async function disconnect() {
+            await rpc.disconnect();
+            pc.close();
+          }
+          pc.get_service = getService;
+          pc.getService = getService;
+          pc.disconnect = disconnect;
+          pc.register_codec = rpc.register_codec;
+          pc.registerCodec = rpc.register_codec;
+          resolve(pc);
+        }, 500);
+      };
+
+      channel.onclose = () => reject(new Error("Data channel closed"));
+
+      await pc.setRemoteDescription(
+        new RTCSessionDescription({
+          sdp: answer.sdp,
+          type: answer.type,
+        }),
+      );
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+async function registerRTCService(server, service_id, config) {
+  config = config || {
+    visibility: "protected",
+    require_context: true,
+  };
+  const onInit = config.on_init;
+  delete config.on_init;
+  await server.registerService({
+    id: service_id,
+    config,
+    offer: (params, context) =>
+      _createOffer(params, server, config, onInit, context),
+  });
+}
+
+
+
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/CachedKeyDecoder.mjs":
+/*!*************************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/CachedKeyDecoder.mjs ***!
+  \*************************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   CachedKeyDecoder: () => (/* binding */ CachedKeyDecoder)
+/* harmony export */ });
+/* harmony import */ var _utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils/utf8.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs");
+
+var DEFAULT_MAX_KEY_LENGTH = 16;
+var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+var CachedKeyDecoder = /** @class */ (function () {
+    function CachedKeyDecoder(maxKeyLength, maxLengthPerKey) {
+        if (maxKeyLength === void 0) { maxKeyLength = DEFAULT_MAX_KEY_LENGTH; }
+        if (maxLengthPerKey === void 0) { maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY; }
+        this.maxKeyLength = maxKeyLength;
+        this.maxLengthPerKey = maxLengthPerKey;
+        this.hit = 0;
+        this.miss = 0;
+        // avoid `new Array(N)`, which makes a sparse array,
+        // because a sparse array is typically slower than a non-sparse array.
+        this.caches = [];
+        for (var i = 0; i < this.maxKeyLength; i++) {
+            this.caches.push([]);
+        }
+    }
+    CachedKeyDecoder.prototype.canBeCached = function (byteLength) {
+        return byteLength > 0 && byteLength <= this.maxKeyLength;
+    };
+    CachedKeyDecoder.prototype.find = function (bytes, inputOffset, byteLength) {
+        var records = this.caches[byteLength - 1];
+        FIND_CHUNK: for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {
+            var record = records_1[_i];
+            var recordBytes = record.bytes;
+            for (var j = 0; j < byteLength; j++) {
+                if (recordBytes[j] !== bytes[inputOffset + j]) {
+                    continue FIND_CHUNK;
+                }
+            }
+            return record.str;
+        }
+        return null;
+    };
+    CachedKeyDecoder.prototype.store = function (bytes, value) {
+        var records = this.caches[bytes.length - 1];
+        var record = { bytes: bytes, str: value };
+        if (records.length >= this.maxLengthPerKey) {
+            // `records` are full!
+            // Set `record` to an arbitrary position.
+            records[(Math.random() * records.length) | 0] = record;
+        }
+        else {
+            records.push(record);
+        }
+    };
+    CachedKeyDecoder.prototype.decode = function (bytes, inputOffset, byteLength) {
+        var cachedValue = this.find(bytes, inputOffset, byteLength);
+        if (cachedValue != null) {
+            this.hit++;
+            return cachedValue;
+        }
+        this.miss++;
+        var str = (0,_utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_0__.utf8DecodeJs)(bytes, inputOffset, byteLength);
+        // Ensure to copy a slice of bytes because the byte may be NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.
+        var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+        this.store(slicedCopyOfBytes, str);
+        return str;
+    };
+    return CachedKeyDecoder;
+}());
+
+//# sourceMappingURL=CachedKeyDecoder.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/DecodeError.mjs":
+/*!********************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/DecodeError.mjs ***!
+  \********************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DecodeError: () => (/* binding */ DecodeError)
+/* harmony export */ });
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var DecodeError = /** @class */ (function (_super) {
+    __extends(DecodeError, _super);
+    function DecodeError(message) {
+        var _this = _super.call(this, message) || this;
+        // fix the prototype chain in a cross-platform way
+        var proto = Object.create(DecodeError.prototype);
+        Object.setPrototypeOf(_this, proto);
+        Object.defineProperty(_this, "name", {
+            configurable: true,
+            enumerable: false,
+            value: DecodeError.name,
+        });
+        return _this;
+    }
+    return DecodeError;
+}(Error));
+
+//# sourceMappingURL=DecodeError.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/Decoder.mjs":
+/*!****************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/Decoder.mjs ***!
+  \****************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DataViewIndexOutOfBoundsError: () => (/* binding */ DataViewIndexOutOfBoundsError),
+/* harmony export */   Decoder: () => (/* binding */ Decoder)
+/* harmony export */ });
+/* harmony import */ var _utils_prettyByte_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./utils/prettyByte.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/prettyByte.mjs");
+/* harmony import */ var _ExtensionCodec_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ExtensionCodec.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/ExtensionCodec.mjs");
+/* harmony import */ var _utils_int_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils/int.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs");
+/* harmony import */ var _utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./utils/utf8.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs");
+/* harmony import */ var _utils_typedArrays_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./utils/typedArrays.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/typedArrays.mjs");
+/* harmony import */ var _CachedKeyDecoder_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./CachedKeyDecoder.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/CachedKeyDecoder.mjs");
+/* harmony import */ var _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./DecodeError.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/DecodeError.mjs");
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (undefined && undefined.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (undefined && undefined.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+
+
+
+
+
+
+
+var isValidMapKeyType = function (key) {
+    var keyType = typeof key;
+    return keyType === "string" || keyType === "number";
+};
+var HEAD_BYTE_REQUIRED = -1;
+var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+// IE11: Hack to support IE11.
+// IE11: Drop this hack and just use RangeError when IE11 is obsolete.
+var DataViewIndexOutOfBoundsError = (function () {
+    try {
+        // IE11: The spec says it should throw RangeError,
+        // IE11: but in IE11 it throws TypeError.
+        EMPTY_VIEW.getInt8(0);
+    }
+    catch (e) {
+        return e.constructor;
+    }
+    throw new Error("never reached");
+})();
+var MORE_DATA = new DataViewIndexOutOfBoundsError("Insufficient data");
+var sharedCachedKeyDecoder = new _CachedKeyDecoder_mjs__WEBPACK_IMPORTED_MODULE_0__.CachedKeyDecoder();
+var Decoder = /** @class */ (function () {
+    function Decoder(extensionCodec, context, maxStrLength, maxBinLength, maxArrayLength, maxMapLength, maxExtLength, keyDecoder) {
+        if (extensionCodec === void 0) { extensionCodec = _ExtensionCodec_mjs__WEBPACK_IMPORTED_MODULE_1__.ExtensionCodec.defaultCodec; }
+        if (context === void 0) { context = undefined; }
+        if (maxStrLength === void 0) { maxStrLength = _utils_int_mjs__WEBPACK_IMPORTED_MODULE_2__.UINT32_MAX; }
+        if (maxBinLength === void 0) { maxBinLength = _utils_int_mjs__WEBPACK_IMPORTED_MODULE_2__.UINT32_MAX; }
+        if (maxArrayLength === void 0) { maxArrayLength = _utils_int_mjs__WEBPACK_IMPORTED_MODULE_2__.UINT32_MAX; }
+        if (maxMapLength === void 0) { maxMapLength = _utils_int_mjs__WEBPACK_IMPORTED_MODULE_2__.UINT32_MAX; }
+        if (maxExtLength === void 0) { maxExtLength = _utils_int_mjs__WEBPACK_IMPORTED_MODULE_2__.UINT32_MAX; }
+        if (keyDecoder === void 0) { keyDecoder = sharedCachedKeyDecoder; }
+        this.extensionCodec = extensionCodec;
+        this.context = context;
+        this.maxStrLength = maxStrLength;
+        this.maxBinLength = maxBinLength;
+        this.maxArrayLength = maxArrayLength;
+        this.maxMapLength = maxMapLength;
+        this.maxExtLength = maxExtLength;
+        this.keyDecoder = keyDecoder;
+        this.totalPos = 0;
+        this.pos = 0;
+        this.view = EMPTY_VIEW;
+        this.bytes = EMPTY_BYTES;
+        this.headByte = HEAD_BYTE_REQUIRED;
+        this.stack = [];
+    }
+    Decoder.prototype.reinitializeState = function () {
+        this.totalPos = 0;
+        this.headByte = HEAD_BYTE_REQUIRED;
+        this.stack.length = 0;
+        // view, bytes, and pos will be re-initialized in setBuffer()
+    };
+    Decoder.prototype.setBuffer = function (buffer) {
+        this.bytes = (0,_utils_typedArrays_mjs__WEBPACK_IMPORTED_MODULE_3__.ensureUint8Array)(buffer);
+        this.view = (0,_utils_typedArrays_mjs__WEBPACK_IMPORTED_MODULE_3__.createDataView)(this.bytes);
+        this.pos = 0;
+    };
+    Decoder.prototype.appendBuffer = function (buffer) {
+        if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+            this.setBuffer(buffer);
+        }
+        else {
+            var remainingData = this.bytes.subarray(this.pos);
+            var newData = (0,_utils_typedArrays_mjs__WEBPACK_IMPORTED_MODULE_3__.ensureUint8Array)(buffer);
+            // concat remainingData + newData
+            var newBuffer = new Uint8Array(remainingData.length + newData.length);
+            newBuffer.set(remainingData);
+            newBuffer.set(newData, remainingData.length);
+            this.setBuffer(newBuffer);
+        }
+    };
+    Decoder.prototype.hasRemaining = function (size) {
+        return this.view.byteLength - this.pos >= size;
+    };
+    Decoder.prototype.createExtraByteError = function (posToShow) {
+        var _a = this, view = _a.view, pos = _a.pos;
+        return new RangeError("Extra ".concat(view.byteLength - pos, " of ").concat(view.byteLength, " byte(s) found at buffer[").concat(posToShow, "]"));
+    };
+    /**
+     * @throws {@link DecodeError}
+     * @throws {@link RangeError}
+     */
+    Decoder.prototype.decode = function (buffer) {
+        this.reinitializeState();
+        this.setBuffer(buffer);
+        var object = this.doDecodeSync();
+        if (this.hasRemaining(1)) {
+            throw this.createExtraByteError(this.pos);
+        }
+        return object;
+    };
+    Decoder.prototype.decodeMulti = function (buffer) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    this.reinitializeState();
+                    this.setBuffer(buffer);
+                    _a.label = 1;
+                case 1:
+                    if (!this.hasRemaining(1)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, this.doDecodeSync()];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/];
+            }
+        });
+    };
+    Decoder.prototype.decodeAsync = function (stream) {
+        var stream_1, stream_1_1;
+        var e_1, _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var decoded, object, buffer, e_1_1, _b, headByte, pos, totalPos;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        decoded = false;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 6, 7, 12]);
+                        stream_1 = __asyncValues(stream);
+                        _c.label = 2;
+                    case 2: return [4 /*yield*/, stream_1.next()];
+                    case 3:
+                        if (!(stream_1_1 = _c.sent(), !stream_1_1.done)) return [3 /*break*/, 5];
+                        buffer = stream_1_1.value;
+                        if (decoded) {
+                            throw this.createExtraByteError(this.totalPos);
+                        }
+                        this.appendBuffer(buffer);
+                        try {
+                            object = this.doDecodeSync();
+                            decoded = true;
+                        }
+                        catch (e) {
+                            if (!(e instanceof DataViewIndexOutOfBoundsError)) {
+                                throw e; // rethrow
+                            }
+                            // fallthrough
+                        }
+                        this.totalPos += this.pos;
+                        _c.label = 4;
+                    case 4: return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 12];
+                    case 6:
+                        e_1_1 = _c.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 12];
+                    case 7:
+                        _c.trys.push([7, , 10, 11]);
+                        if (!(stream_1_1 && !stream_1_1.done && (_a = stream_1.return))) return [3 /*break*/, 9];
+                        return [4 /*yield*/, _a.call(stream_1)];
+                    case 8:
+                        _c.sent();
+                        _c.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 11: return [7 /*endfinally*/];
+                    case 12:
+                        if (decoded) {
+                            if (this.hasRemaining(1)) {
+                                throw this.createExtraByteError(this.totalPos);
+                            }
+                            return [2 /*return*/, object];
+                        }
+                        _b = this, headByte = _b.headByte, pos = _b.pos, totalPos = _b.totalPos;
+                        throw new RangeError("Insufficient data in parsing ".concat((0,_utils_prettyByte_mjs__WEBPACK_IMPORTED_MODULE_4__.prettyByte)(headByte), " at ").concat(totalPos, " (").concat(pos, " in the current buffer)"));
+                }
+            });
+        });
+    };
+    Decoder.prototype.decodeArrayStream = function (stream) {
+        return this.decodeMultiAsync(stream, true);
+    };
+    Decoder.prototype.decodeStream = function (stream) {
+        return this.decodeMultiAsync(stream, false);
+    };
+    Decoder.prototype.decodeMultiAsync = function (stream, isArray) {
+        return __asyncGenerator(this, arguments, function decodeMultiAsync_1() {
+            var isArrayHeaderRequired, arrayItemsLeft, stream_2, stream_2_1, buffer, e_2, e_3_1;
+            var e_3, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        isArrayHeaderRequired = isArray;
+                        arrayItemsLeft = -1;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 13, 14, 19]);
+                        stream_2 = __asyncValues(stream);
+                        _b.label = 2;
+                    case 2: return [4 /*yield*/, __await(stream_2.next())];
+                    case 3:
+                        if (!(stream_2_1 = _b.sent(), !stream_2_1.done)) return [3 /*break*/, 12];
+                        buffer = stream_2_1.value;
+                        if (isArray && arrayItemsLeft === 0) {
+                            throw this.createExtraByteError(this.totalPos);
+                        }
+                        this.appendBuffer(buffer);
+                        if (isArrayHeaderRequired) {
+                            arrayItemsLeft = this.readArraySize();
+                            isArrayHeaderRequired = false;
+                            this.complete();
+                        }
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 9, , 10]);
+                        _b.label = 5;
+                    case 5:
+                        if (false) {}
+                        return [4 /*yield*/, __await(this.doDecodeSync())];
+                    case 6: return [4 /*yield*/, _b.sent()];
+                    case 7:
+                        _b.sent();
+                        if (--arrayItemsLeft === 0) {
+                            return [3 /*break*/, 8];
+                        }
+                        return [3 /*break*/, 5];
+                    case 8: return [3 /*break*/, 10];
+                    case 9:
+                        e_2 = _b.sent();
+                        if (!(e_2 instanceof DataViewIndexOutOfBoundsError)) {
+                            throw e_2; // rethrow
+                        }
+                        return [3 /*break*/, 10];
+                    case 10:
+                        this.totalPos += this.pos;
+                        _b.label = 11;
+                    case 11: return [3 /*break*/, 2];
+                    case 12: return [3 /*break*/, 19];
+                    case 13:
+                        e_3_1 = _b.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 19];
+                    case 14:
+                        _b.trys.push([14, , 17, 18]);
+                        if (!(stream_2_1 && !stream_2_1.done && (_a = stream_2.return))) return [3 /*break*/, 16];
+                        return [4 /*yield*/, __await(_a.call(stream_2))];
+                    case 15:
+                        _b.sent();
+                        _b.label = 16;
+                    case 16: return [3 /*break*/, 18];
+                    case 17:
+                        if (e_3) throw e_3.error;
+                        return [7 /*endfinally*/];
+                    case 18: return [7 /*endfinally*/];
+                    case 19: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Decoder.prototype.doDecodeSync = function () {
+        DECODE: while (true) {
+            var headByte = this.readHeadByte();
+            var object = void 0;
+            if (headByte >= 0xe0) {
+                // negative fixint (111x xxxx) 0xe0 - 0xff
+                object = headByte - 0x100;
+            }
+            else if (headByte < 0xc0) {
+                if (headByte < 0x80) {
+                    // positive fixint (0xxx xxxx) 0x00 - 0x7f
+                    object = headByte;
+                }
+                else if (headByte < 0x90) {
+                    // fixmap (1000 xxxx) 0x80 - 0x8f
+                    var size = headByte - 0x80;
+                    if (size !== 0) {
+                        this.pushMapState(size);
+                        this.complete();
+                        continue DECODE;
+                    }
+                    else {
+                        object = {};
+                    }
+                }
+                else if (headByte < 0xa0) {
+                    // fixarray (1001 xxxx) 0x90 - 0x9f
+                    var size = headByte - 0x90;
+                    if (size !== 0) {
+                        this.pushArrayState(size);
+                        this.complete();
+                        continue DECODE;
+                    }
+                    else {
+                        object = [];
+                    }
+                }
+                else {
+                    // fixstr (101x xxxx) 0xa0 - 0xbf
+                    var byteLength = headByte - 0xa0;
+                    object = this.decodeUtf8String(byteLength, 0);
+                }
+            }
+            else if (headByte === 0xc0) {
+                // nil
+                object = null;
+            }
+            else if (headByte === 0xc2) {
+                // false
+                object = false;
+            }
+            else if (headByte === 0xc3) {
+                // true
+                object = true;
+            }
+            else if (headByte === 0xca) {
+                // float 32
+                object = this.readF32();
+            }
+            else if (headByte === 0xcb) {
+                // float 64
+                object = this.readF64();
+            }
+            else if (headByte === 0xcc) {
+                // uint 8
+                object = this.readU8();
+            }
+            else if (headByte === 0xcd) {
+                // uint 16
+                object = this.readU16();
+            }
+            else if (headByte === 0xce) {
+                // uint 32
+                object = this.readU32();
+            }
+            else if (headByte === 0xcf) {
+                // uint 64
+                object = this.readU64();
+            }
+            else if (headByte === 0xd0) {
+                // int 8
+                object = this.readI8();
+            }
+            else if (headByte === 0xd1) {
+                // int 16
+                object = this.readI16();
+            }
+            else if (headByte === 0xd2) {
+                // int 32
+                object = this.readI32();
+            }
+            else if (headByte === 0xd3) {
+                // int 64
+                object = this.readI64();
+            }
+            else if (headByte === 0xd9) {
+                // str 8
+                var byteLength = this.lookU8();
+                object = this.decodeUtf8String(byteLength, 1);
+            }
+            else if (headByte === 0xda) {
+                // str 16
+                var byteLength = this.lookU16();
+                object = this.decodeUtf8String(byteLength, 2);
+            }
+            else if (headByte === 0xdb) {
+                // str 32
+                var byteLength = this.lookU32();
+                object = this.decodeUtf8String(byteLength, 4);
+            }
+            else if (headByte === 0xdc) {
+                // array 16
+                var size = this.readU16();
+                if (size !== 0) {
+                    this.pushArrayState(size);
+                    this.complete();
+                    continue DECODE;
+                }
+                else {
+                    object = [];
+                }
+            }
+            else if (headByte === 0xdd) {
+                // array 32
+                var size = this.readU32();
+                if (size !== 0) {
+                    this.pushArrayState(size);
+                    this.complete();
+                    continue DECODE;
+                }
+                else {
+                    object = [];
+                }
+            }
+            else if (headByte === 0xde) {
+                // map 16
+                var size = this.readU16();
+                if (size !== 0) {
+                    this.pushMapState(size);
+                    this.complete();
+                    continue DECODE;
+                }
+                else {
+                    object = {};
+                }
+            }
+            else if (headByte === 0xdf) {
+                // map 32
+                var size = this.readU32();
+                if (size !== 0) {
+                    this.pushMapState(size);
+                    this.complete();
+                    continue DECODE;
+                }
+                else {
+                    object = {};
+                }
+            }
+            else if (headByte === 0xc4) {
+                // bin 8
+                var size = this.lookU8();
+                object = this.decodeBinary(size, 1);
+            }
+            else if (headByte === 0xc5) {
+                // bin 16
+                var size = this.lookU16();
+                object = this.decodeBinary(size, 2);
+            }
+            else if (headByte === 0xc6) {
+                // bin 32
+                var size = this.lookU32();
+                object = this.decodeBinary(size, 4);
+            }
+            else if (headByte === 0xd4) {
+                // fixext 1
+                object = this.decodeExtension(1, 0);
+            }
+            else if (headByte === 0xd5) {
+                // fixext 2
+                object = this.decodeExtension(2, 0);
+            }
+            else if (headByte === 0xd6) {
+                // fixext 4
+                object = this.decodeExtension(4, 0);
+            }
+            else if (headByte === 0xd7) {
+                // fixext 8
+                object = this.decodeExtension(8, 0);
+            }
+            else if (headByte === 0xd8) {
+                // fixext 16
+                object = this.decodeExtension(16, 0);
+            }
+            else if (headByte === 0xc7) {
+                // ext 8
+                var size = this.lookU8();
+                object = this.decodeExtension(size, 1);
+            }
+            else if (headByte === 0xc8) {
+                // ext 16
+                var size = this.lookU16();
+                object = this.decodeExtension(size, 2);
+            }
+            else if (headByte === 0xc9) {
+                // ext 32
+                var size = this.lookU32();
+                object = this.decodeExtension(size, 4);
+            }
+            else {
+                throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__.DecodeError("Unrecognized type byte: ".concat((0,_utils_prettyByte_mjs__WEBPACK_IMPORTED_MODULE_4__.prettyByte)(headByte)));
+            }
+            this.complete();
+            var stack = this.stack;
+            while (stack.length > 0) {
+                // arrays and maps
+                var state = stack[stack.length - 1];
+                if (state.type === 0 /* State.ARRAY */) {
+                    state.array[state.position] = object;
+                    state.position++;
+                    if (state.position === state.size) {
+                        stack.pop();
+                        object = state.array;
+                    }
+                    else {
+                        continue DECODE;
+                    }
+                }
+                else if (state.type === 1 /* State.MAP_KEY */) {
+                    if (!isValidMapKeyType(object)) {
+                        throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__.DecodeError("The type of key must be string or number but " + typeof object);
+                    }
+                    if (object === "__proto__") {
+                        throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__.DecodeError("The key __proto__ is not allowed");
+                    }
+                    state.key = object;
+                    state.type = 2 /* State.MAP_VALUE */;
+                    continue DECODE;
+                }
+                else {
+                    // it must be `state.type === State.MAP_VALUE` here
+                    state.map[state.key] = object;
+                    state.readCount++;
+                    if (state.readCount === state.size) {
+                        stack.pop();
+                        object = state.map;
+                    }
+                    else {
+                        state.key = null;
+                        state.type = 1 /* State.MAP_KEY */;
+                        continue DECODE;
+                    }
+                }
+            }
+            return object;
+        }
+    };
+    Decoder.prototype.readHeadByte = function () {
+        if (this.headByte === HEAD_BYTE_REQUIRED) {
+            this.headByte = this.readU8();
+            // console.log("headByte", prettyByte(this.headByte));
+        }
+        return this.headByte;
+    };
+    Decoder.prototype.complete = function () {
+        this.headByte = HEAD_BYTE_REQUIRED;
+    };
+    Decoder.prototype.readArraySize = function () {
+        var headByte = this.readHeadByte();
+        switch (headByte) {
+            case 0xdc:
+                return this.readU16();
+            case 0xdd:
+                return this.readU32();
+            default: {
+                if (headByte < 0xa0) {
+                    return headByte - 0x90;
+                }
+                else {
+                    throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__.DecodeError("Unrecognized array type byte: ".concat((0,_utils_prettyByte_mjs__WEBPACK_IMPORTED_MODULE_4__.prettyByte)(headByte)));
+                }
+            }
+        }
+    };
+    Decoder.prototype.pushMapState = function (size) {
+        if (size > this.maxMapLength) {
+            throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__.DecodeError("Max length exceeded: map length (".concat(size, ") > maxMapLengthLength (").concat(this.maxMapLength, ")"));
+        }
+        this.stack.push({
+            type: 1 /* State.MAP_KEY */,
+            size: size,
+            key: null,
+            readCount: 0,
+            map: {},
+        });
+    };
+    Decoder.prototype.pushArrayState = function (size) {
+        if (size > this.maxArrayLength) {
+            throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__.DecodeError("Max length exceeded: array length (".concat(size, ") > maxArrayLength (").concat(this.maxArrayLength, ")"));
+        }
+        this.stack.push({
+            type: 0 /* State.ARRAY */,
+            size: size,
+            array: new Array(size),
+            position: 0,
+        });
+    };
+    Decoder.prototype.decodeUtf8String = function (byteLength, headerOffset) {
+        var _a;
+        if (byteLength > this.maxStrLength) {
+            throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__.DecodeError("Max length exceeded: UTF-8 byte length (".concat(byteLength, ") > maxStrLength (").concat(this.maxStrLength, ")"));
+        }
+        if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
+            throw MORE_DATA;
+        }
+        var offset = this.pos + headerOffset;
+        var object;
+        if (this.stateIsMapKey() && ((_a = this.keyDecoder) === null || _a === void 0 ? void 0 : _a.canBeCached(byteLength))) {
+            object = this.keyDecoder.decode(this.bytes, offset, byteLength);
+        }
+        else if (byteLength > _utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_6__.TEXT_DECODER_THRESHOLD) {
+            object = (0,_utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_6__.utf8DecodeTD)(this.bytes, offset, byteLength);
+        }
+        else {
+            object = (0,_utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_6__.utf8DecodeJs)(this.bytes, offset, byteLength);
+        }
+        this.pos += headerOffset + byteLength;
+        return object;
+    };
+    Decoder.prototype.stateIsMapKey = function () {
+        if (this.stack.length > 0) {
+            var state = this.stack[this.stack.length - 1];
+            return state.type === 1 /* State.MAP_KEY */;
+        }
+        return false;
+    };
+    Decoder.prototype.decodeBinary = function (byteLength, headOffset) {
+        if (byteLength > this.maxBinLength) {
+            throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__.DecodeError("Max length exceeded: bin length (".concat(byteLength, ") > maxBinLength (").concat(this.maxBinLength, ")"));
+        }
+        if (!this.hasRemaining(byteLength + headOffset)) {
+            throw MORE_DATA;
+        }
+        var offset = this.pos + headOffset;
+        var object = this.bytes.subarray(offset, offset + byteLength);
+        this.pos += headOffset + byteLength;
+        return object;
+    };
+    Decoder.prototype.decodeExtension = function (size, headOffset) {
+        if (size > this.maxExtLength) {
+            throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_5__.DecodeError("Max length exceeded: ext length (".concat(size, ") > maxExtLength (").concat(this.maxExtLength, ")"));
+        }
+        var extType = this.view.getInt8(this.pos + headOffset);
+        var data = this.decodeBinary(size, headOffset + 1 /* extType */);
+        return this.extensionCodec.decode(data, extType, this.context);
+    };
+    Decoder.prototype.lookU8 = function () {
+        return this.view.getUint8(this.pos);
+    };
+    Decoder.prototype.lookU16 = function () {
+        return this.view.getUint16(this.pos);
+    };
+    Decoder.prototype.lookU32 = function () {
+        return this.view.getUint32(this.pos);
+    };
+    Decoder.prototype.readU8 = function () {
+        var value = this.view.getUint8(this.pos);
+        this.pos++;
+        return value;
+    };
+    Decoder.prototype.readI8 = function () {
+        var value = this.view.getInt8(this.pos);
+        this.pos++;
+        return value;
+    };
+    Decoder.prototype.readU16 = function () {
+        var value = this.view.getUint16(this.pos);
+        this.pos += 2;
+        return value;
+    };
+    Decoder.prototype.readI16 = function () {
+        var value = this.view.getInt16(this.pos);
+        this.pos += 2;
+        return value;
+    };
+    Decoder.prototype.readU32 = function () {
+        var value = this.view.getUint32(this.pos);
+        this.pos += 4;
+        return value;
+    };
+    Decoder.prototype.readI32 = function () {
+        var value = this.view.getInt32(this.pos);
+        this.pos += 4;
+        return value;
+    };
+    Decoder.prototype.readU64 = function () {
+        var value = (0,_utils_int_mjs__WEBPACK_IMPORTED_MODULE_2__.getUint64)(this.view, this.pos);
+        this.pos += 8;
+        return value;
+    };
+    Decoder.prototype.readI64 = function () {
+        var value = (0,_utils_int_mjs__WEBPACK_IMPORTED_MODULE_2__.getInt64)(this.view, this.pos);
+        this.pos += 8;
+        return value;
+    };
+    Decoder.prototype.readF32 = function () {
+        var value = this.view.getFloat32(this.pos);
+        this.pos += 4;
+        return value;
+    };
+    Decoder.prototype.readF64 = function () {
+        var value = this.view.getFloat64(this.pos);
+        this.pos += 8;
+        return value;
+    };
+    return Decoder;
+}());
+
+//# sourceMappingURL=Decoder.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/Encoder.mjs":
+/*!****************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/Encoder.mjs ***!
+  \****************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DEFAULT_INITIAL_BUFFER_SIZE: () => (/* binding */ DEFAULT_INITIAL_BUFFER_SIZE),
+/* harmony export */   DEFAULT_MAX_DEPTH: () => (/* binding */ DEFAULT_MAX_DEPTH),
+/* harmony export */   Encoder: () => (/* binding */ Encoder)
+/* harmony export */ });
+/* harmony import */ var _utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils/utf8.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs");
+/* harmony import */ var _ExtensionCodec_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ExtensionCodec.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/ExtensionCodec.mjs");
+/* harmony import */ var _utils_int_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./utils/int.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs");
+/* harmony import */ var _utils_typedArrays_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils/typedArrays.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/typedArrays.mjs");
+
+
+
+
+var DEFAULT_MAX_DEPTH = 100;
+var DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+var Encoder = /** @class */ (function () {
+    function Encoder(extensionCodec, context, maxDepth, initialBufferSize, sortKeys, forceFloat32, ignoreUndefined, forceIntegerToFloat) {
+        if (extensionCodec === void 0) { extensionCodec = _ExtensionCodec_mjs__WEBPACK_IMPORTED_MODULE_0__.ExtensionCodec.defaultCodec; }
+        if (context === void 0) { context = undefined; }
+        if (maxDepth === void 0) { maxDepth = DEFAULT_MAX_DEPTH; }
+        if (initialBufferSize === void 0) { initialBufferSize = DEFAULT_INITIAL_BUFFER_SIZE; }
+        if (sortKeys === void 0) { sortKeys = false; }
+        if (forceFloat32 === void 0) { forceFloat32 = false; }
+        if (ignoreUndefined === void 0) { ignoreUndefined = false; }
+        if (forceIntegerToFloat === void 0) { forceIntegerToFloat = false; }
+        this.extensionCodec = extensionCodec;
+        this.context = context;
+        this.maxDepth = maxDepth;
+        this.initialBufferSize = initialBufferSize;
+        this.sortKeys = sortKeys;
+        this.forceFloat32 = forceFloat32;
+        this.ignoreUndefined = ignoreUndefined;
+        this.forceIntegerToFloat = forceIntegerToFloat;
+        this.pos = 0;
+        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+        this.bytes = new Uint8Array(this.view.buffer);
+    }
+    Encoder.prototype.reinitializeState = function () {
+        this.pos = 0;
+    };
+    /**
+     * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+     *
+     * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+     */
+    Encoder.prototype.encodeSharedRef = function (object) {
+        this.reinitializeState();
+        this.doEncode(object, 1);
+        return this.bytes.subarray(0, this.pos);
+    };
+    /**
+     * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+     */
+    Encoder.prototype.encode = function (object) {
+        this.reinitializeState();
+        this.doEncode(object, 1);
+        return this.bytes.slice(0, this.pos);
+    };
+    Encoder.prototype.doEncode = function (object, depth) {
+        if (depth > this.maxDepth) {
+            throw new Error("Too deep objects in depth ".concat(depth));
+        }
+        if (object == null) {
+            this.encodeNil();
+        }
+        else if (typeof object === "boolean") {
+            this.encodeBoolean(object);
+        }
+        else if (typeof object === "number") {
+            this.encodeNumber(object);
+        }
+        else if (typeof object === "string") {
+            this.encodeString(object);
+        }
+        else {
+            this.encodeObject(object, depth);
+        }
+    };
+    Encoder.prototype.ensureBufferSizeToWrite = function (sizeToWrite) {
+        var requiredSize = this.pos + sizeToWrite;
+        if (this.view.byteLength < requiredSize) {
+            this.resizeBuffer(requiredSize * 2);
+        }
+    };
+    Encoder.prototype.resizeBuffer = function (newSize) {
+        var newBuffer = new ArrayBuffer(newSize);
+        var newBytes = new Uint8Array(newBuffer);
+        var newView = new DataView(newBuffer);
+        newBytes.set(this.bytes);
+        this.view = newView;
+        this.bytes = newBytes;
+    };
+    Encoder.prototype.encodeNil = function () {
+        this.writeU8(0xc0);
+    };
+    Encoder.prototype.encodeBoolean = function (object) {
+        if (object === false) {
+            this.writeU8(0xc2);
+        }
+        else {
+            this.writeU8(0xc3);
+        }
+    };
+    Encoder.prototype.encodeNumber = function (object) {
+        if (Number.isSafeInteger(object) && !this.forceIntegerToFloat) {
+            if (object >= 0) {
+                if (object < 0x80) {
+                    // positive fixint
+                    this.writeU8(object);
+                }
+                else if (object < 0x100) {
+                    // uint 8
+                    this.writeU8(0xcc);
+                    this.writeU8(object);
+                }
+                else if (object < 0x10000) {
+                    // uint 16
+                    this.writeU8(0xcd);
+                    this.writeU16(object);
+                }
+                else if (object < 0x100000000) {
+                    // uint 32
+                    this.writeU8(0xce);
+                    this.writeU32(object);
+                }
+                else {
+                    // uint 64
+                    this.writeU8(0xcf);
+                    this.writeU64(object);
+                }
+            }
+            else {
+                if (object >= -0x20) {
+                    // negative fixint
+                    this.writeU8(0xe0 | (object + 0x20));
+                }
+                else if (object >= -0x80) {
+                    // int 8
+                    this.writeU8(0xd0);
+                    this.writeI8(object);
+                }
+                else if (object >= -0x8000) {
+                    // int 16
+                    this.writeU8(0xd1);
+                    this.writeI16(object);
+                }
+                else if (object >= -0x80000000) {
+                    // int 32
+                    this.writeU8(0xd2);
+                    this.writeI32(object);
+                }
+                else {
+                    // int 64
+                    this.writeU8(0xd3);
+                    this.writeI64(object);
+                }
+            }
+        }
+        else {
+            // non-integer numbers
+            if (this.forceFloat32) {
+                // float 32
+                this.writeU8(0xca);
+                this.writeF32(object);
+            }
+            else {
+                // float 64
+                this.writeU8(0xcb);
+                this.writeF64(object);
+            }
+        }
+    };
+    Encoder.prototype.writeStringHeader = function (byteLength) {
+        if (byteLength < 32) {
+            // fixstr
+            this.writeU8(0xa0 + byteLength);
+        }
+        else if (byteLength < 0x100) {
+            // str 8
+            this.writeU8(0xd9);
+            this.writeU8(byteLength);
+        }
+        else if (byteLength < 0x10000) {
+            // str 16
+            this.writeU8(0xda);
+            this.writeU16(byteLength);
+        }
+        else if (byteLength < 0x100000000) {
+            // str 32
+            this.writeU8(0xdb);
+            this.writeU32(byteLength);
+        }
+        else {
+            throw new Error("Too long string: ".concat(byteLength, " bytes in UTF-8"));
+        }
+    };
+    Encoder.prototype.encodeString = function (object) {
+        var maxHeaderSize = 1 + 4;
+        var strLength = object.length;
+        if (strLength > _utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_1__.TEXT_ENCODER_THRESHOLD) {
+            var byteLength = (0,_utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_1__.utf8Count)(object);
+            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+            this.writeStringHeader(byteLength);
+            (0,_utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_1__.utf8EncodeTE)(object, this.bytes, this.pos);
+            this.pos += byteLength;
+        }
+        else {
+            var byteLength = (0,_utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_1__.utf8Count)(object);
+            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+            this.writeStringHeader(byteLength);
+            (0,_utils_utf8_mjs__WEBPACK_IMPORTED_MODULE_1__.utf8EncodeJs)(object, this.bytes, this.pos);
+            this.pos += byteLength;
+        }
+    };
+    Encoder.prototype.encodeObject = function (object, depth) {
+        // try to encode objects with custom codec first of non-primitives
+        var ext = this.extensionCodec.tryToEncode(object, this.context);
+        if (ext != null) {
+            this.encodeExtension(ext);
+        }
+        else if (Array.isArray(object)) {
+            this.encodeArray(object, depth);
+        }
+        else if (ArrayBuffer.isView(object)) {
+            this.encodeBinary(object);
+        }
+        else if (typeof object === "object") {
+            this.encodeMap(object, depth);
+        }
+        else {
+            // symbol, function and other special object come here unless extensionCodec handles them.
+            throw new Error("Unrecognized object: ".concat(Object.prototype.toString.apply(object)));
+        }
+    };
+    Encoder.prototype.encodeBinary = function (object) {
+        var size = object.byteLength;
+        if (size < 0x100) {
+            // bin 8
+            this.writeU8(0xc4);
+            this.writeU8(size);
+        }
+        else if (size < 0x10000) {
+            // bin 16
+            this.writeU8(0xc5);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // bin 32
+            this.writeU8(0xc6);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error("Too large binary: ".concat(size));
+        }
+        var bytes = (0,_utils_typedArrays_mjs__WEBPACK_IMPORTED_MODULE_2__.ensureUint8Array)(object);
+        this.writeU8a(bytes);
+    };
+    Encoder.prototype.encodeArray = function (object, depth) {
+        var size = object.length;
+        if (size < 16) {
+            // fixarray
+            this.writeU8(0x90 + size);
+        }
+        else if (size < 0x10000) {
+            // array 16
+            this.writeU8(0xdc);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // array 32
+            this.writeU8(0xdd);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error("Too large array: ".concat(size));
+        }
+        for (var _i = 0, object_1 = object; _i < object_1.length; _i++) {
+            var item = object_1[_i];
+            this.doEncode(item, depth + 1);
+        }
+    };
+    Encoder.prototype.countWithoutUndefined = function (object, keys) {
+        var count = 0;
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
+            if (object[key] !== undefined) {
+                count++;
+            }
+        }
+        return count;
+    };
+    Encoder.prototype.encodeMap = function (object, depth) {
+        var keys = Object.keys(object);
+        if (this.sortKeys) {
+            keys.sort();
+        }
+        var size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+        if (size < 16) {
+            // fixmap
+            this.writeU8(0x80 + size);
+        }
+        else if (size < 0x10000) {
+            // map 16
+            this.writeU8(0xde);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // map 32
+            this.writeU8(0xdf);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error("Too large map object: ".concat(size));
+        }
+        for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
+            var key = keys_2[_i];
+            var value = object[key];
+            if (!(this.ignoreUndefined && value === undefined)) {
+                this.encodeString(key);
+                this.doEncode(value, depth + 1);
+            }
+        }
+    };
+    Encoder.prototype.encodeExtension = function (ext) {
+        var size = ext.data.length;
+        if (size === 1) {
+            // fixext 1
+            this.writeU8(0xd4);
+        }
+        else if (size === 2) {
+            // fixext 2
+            this.writeU8(0xd5);
+        }
+        else if (size === 4) {
+            // fixext 4
+            this.writeU8(0xd6);
+        }
+        else if (size === 8) {
+            // fixext 8
+            this.writeU8(0xd7);
+        }
+        else if (size === 16) {
+            // fixext 16
+            this.writeU8(0xd8);
+        }
+        else if (size < 0x100) {
+            // ext 8
+            this.writeU8(0xc7);
+            this.writeU8(size);
+        }
+        else if (size < 0x10000) {
+            // ext 16
+            this.writeU8(0xc8);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // ext 32
+            this.writeU8(0xc9);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error("Too large extension object: ".concat(size));
+        }
+        this.writeI8(ext.type);
+        this.writeU8a(ext.data);
+    };
+    Encoder.prototype.writeU8 = function (value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setUint8(this.pos, value);
+        this.pos++;
+    };
+    Encoder.prototype.writeU8a = function (values) {
+        var size = values.length;
+        this.ensureBufferSizeToWrite(size);
+        this.bytes.set(values, this.pos);
+        this.pos += size;
+    };
+    Encoder.prototype.writeI8 = function (value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setInt8(this.pos, value);
+        this.pos++;
+    };
+    Encoder.prototype.writeU16 = function (value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setUint16(this.pos, value);
+        this.pos += 2;
+    };
+    Encoder.prototype.writeI16 = function (value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setInt16(this.pos, value);
+        this.pos += 2;
+    };
+    Encoder.prototype.writeU32 = function (value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setUint32(this.pos, value);
+        this.pos += 4;
+    };
+    Encoder.prototype.writeI32 = function (value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setInt32(this.pos, value);
+        this.pos += 4;
+    };
+    Encoder.prototype.writeF32 = function (value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setFloat32(this.pos, value);
+        this.pos += 4;
+    };
+    Encoder.prototype.writeF64 = function (value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setFloat64(this.pos, value);
+        this.pos += 8;
+    };
+    Encoder.prototype.writeU64 = function (value) {
+        this.ensureBufferSizeToWrite(8);
+        (0,_utils_int_mjs__WEBPACK_IMPORTED_MODULE_3__.setUint64)(this.view, this.pos, value);
+        this.pos += 8;
+    };
+    Encoder.prototype.writeI64 = function (value) {
+        this.ensureBufferSizeToWrite(8);
+        (0,_utils_int_mjs__WEBPACK_IMPORTED_MODULE_3__.setInt64)(this.view, this.pos, value);
+        this.pos += 8;
+    };
+    return Encoder;
+}());
+
+//# sourceMappingURL=Encoder.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/ExtData.mjs":
+/*!****************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/ExtData.mjs ***!
+  \****************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ExtData: () => (/* binding */ ExtData)
+/* harmony export */ });
+/**
+ * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.
+ */
+var ExtData = /** @class */ (function () {
+    function ExtData(type, data) {
+        this.type = type;
+        this.data = data;
+    }
+    return ExtData;
+}());
+
+//# sourceMappingURL=ExtData.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/ExtensionCodec.mjs":
+/*!***********************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/ExtensionCodec.mjs ***!
+  \***********************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ExtensionCodec: () => (/* binding */ ExtensionCodec)
+/* harmony export */ });
+/* harmony import */ var _ExtData_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ExtData.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/ExtData.mjs");
+/* harmony import */ var _timestamp_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./timestamp.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/timestamp.mjs");
+// ExtensionCodec to handle MessagePack extensions
+
+
+var ExtensionCodec = /** @class */ (function () {
+    function ExtensionCodec() {
+        // built-in extensions
+        this.builtInEncoders = [];
+        this.builtInDecoders = [];
+        // custom extensions
+        this.encoders = [];
+        this.decoders = [];
+        this.register(_timestamp_mjs__WEBPACK_IMPORTED_MODULE_0__.timestampExtension);
+    }
+    ExtensionCodec.prototype.register = function (_a) {
+        var type = _a.type, encode = _a.encode, decode = _a.decode;
+        if (type >= 0) {
+            // custom extensions
+            this.encoders[type] = encode;
+            this.decoders[type] = decode;
+        }
+        else {
+            // built-in extensions
+            var index = 1 + type;
+            this.builtInEncoders[index] = encode;
+            this.builtInDecoders[index] = decode;
+        }
+    };
+    ExtensionCodec.prototype.tryToEncode = function (object, context) {
+        // built-in extensions
+        for (var i = 0; i < this.builtInEncoders.length; i++) {
+            var encodeExt = this.builtInEncoders[i];
+            if (encodeExt != null) {
+                var data = encodeExt(object, context);
+                if (data != null) {
+                    var type = -1 - i;
+                    return new _ExtData_mjs__WEBPACK_IMPORTED_MODULE_1__.ExtData(type, data);
+                }
+            }
+        }
+        // custom extensions
+        for (var i = 0; i < this.encoders.length; i++) {
+            var encodeExt = this.encoders[i];
+            if (encodeExt != null) {
+                var data = encodeExt(object, context);
+                if (data != null) {
+                    var type = i;
+                    return new _ExtData_mjs__WEBPACK_IMPORTED_MODULE_1__.ExtData(type, data);
+                }
+            }
+        }
+        if (object instanceof _ExtData_mjs__WEBPACK_IMPORTED_MODULE_1__.ExtData) {
+            // to keep ExtData as is
+            return object;
+        }
+        return null;
+    };
+    ExtensionCodec.prototype.decode = function (data, type, context) {
+        var decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+        if (decodeExt) {
+            return decodeExt(data, type, context);
+        }
+        else {
+            // decode() does not fail, returns ExtData instead.
+            return new _ExtData_mjs__WEBPACK_IMPORTED_MODULE_1__.ExtData(type, data);
+        }
+    };
+    ExtensionCodec.defaultCodec = new ExtensionCodec();
+    return ExtensionCodec;
+}());
+
+//# sourceMappingURL=ExtensionCodec.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/decode.mjs":
+/*!***************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/decode.mjs ***!
+  \***************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   decode: () => (/* binding */ decode),
+/* harmony export */   decodeMulti: () => (/* binding */ decodeMulti),
+/* harmony export */   defaultDecodeOptions: () => (/* binding */ defaultDecodeOptions)
+/* harmony export */ });
+/* harmony import */ var _Decoder_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Decoder.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/Decoder.mjs");
+
+var defaultDecodeOptions = {};
+/**
+ * It decodes a single MessagePack object in a buffer.
+ *
+ * This is a synchronous decoding function.
+ * See other variants for asynchronous decoding: {@link decodeAsync()}, {@link decodeStream()}, or {@link decodeArrayStream()}.
+ *
+ * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+ * @throws {@link DecodeError} if the buffer contains invalid data.
+ */
+function decode(buffer, options) {
+    if (options === void 0) { options = defaultDecodeOptions; }
+    var decoder = new _Decoder_mjs__WEBPACK_IMPORTED_MODULE_0__.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+    return decoder.decode(buffer);
+}
+/**
+ * It decodes multiple MessagePack objects in a buffer.
+ * This is corresponding to {@link decodeMultiStream()}.
+ *
+ * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+ * @throws {@link DecodeError} if the buffer contains invalid data.
+ */
+function decodeMulti(buffer, options) {
+    if (options === void 0) { options = defaultDecodeOptions; }
+    var decoder = new _Decoder_mjs__WEBPACK_IMPORTED_MODULE_0__.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+    return decoder.decodeMulti(buffer);
+}
+//# sourceMappingURL=decode.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/encode.mjs":
+/*!***************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/encode.mjs ***!
+  \***************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   encode: () => (/* binding */ encode)
+/* harmony export */ });
+/* harmony import */ var _Encoder_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Encoder.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/Encoder.mjs");
+
+var defaultEncodeOptions = {};
+/**
+ * It encodes `value` in the MessagePack format and
+ * returns a byte buffer.
+ *
+ * The returned buffer is a slice of a larger `ArrayBuffer`, so you have to use its `#byteOffset` and `#byteLength` in order to convert it to another typed arrays including NodeJS `Buffer`.
+ */
+function encode(value, options) {
+    if (options === void 0) { options = defaultEncodeOptions; }
+    var encoder = new _Encoder_mjs__WEBPACK_IMPORTED_MODULE_0__.Encoder(options.extensionCodec, options.context, options.maxDepth, options.initialBufferSize, options.sortKeys, options.forceFloat32, options.ignoreUndefined, options.forceIntegerToFloat);
+    return encoder.encodeSharedRef(value);
+}
+//# sourceMappingURL=encode.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/timestamp.mjs":
+/*!******************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/timestamp.mjs ***!
+  \******************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   EXT_TIMESTAMP: () => (/* binding */ EXT_TIMESTAMP),
+/* harmony export */   decodeTimestampExtension: () => (/* binding */ decodeTimestampExtension),
+/* harmony export */   decodeTimestampToTimeSpec: () => (/* binding */ decodeTimestampToTimeSpec),
+/* harmony export */   encodeDateToTimeSpec: () => (/* binding */ encodeDateToTimeSpec),
+/* harmony export */   encodeTimeSpecToTimestamp: () => (/* binding */ encodeTimeSpecToTimestamp),
+/* harmony export */   encodeTimestampExtension: () => (/* binding */ encodeTimestampExtension),
+/* harmony export */   timestampExtension: () => (/* binding */ timestampExtension)
+/* harmony export */ });
+/* harmony import */ var _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./DecodeError.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/DecodeError.mjs");
+/* harmony import */ var _utils_int_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils/int.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs");
+// https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
+
+
+var EXT_TIMESTAMP = -1;
+var TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
+var TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
+function encodeTimeSpecToTimestamp(_a) {
+    var sec = _a.sec, nsec = _a.nsec;
+    if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+        // Here sec >= 0 && nsec >= 0
+        if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+            // timestamp 32 = { sec32 (unsigned) }
+            var rv = new Uint8Array(4);
+            var view = new DataView(rv.buffer);
+            view.setUint32(0, sec);
+            return rv;
+        }
+        else {
+            // timestamp 64 = { nsec30 (unsigned), sec34 (unsigned) }
+            var secHigh = sec / 0x100000000;
+            var secLow = sec & 0xffffffff;
+            var rv = new Uint8Array(8);
+            var view = new DataView(rv.buffer);
+            // nsec30 | secHigh2
+            view.setUint32(0, (nsec << 2) | (secHigh & 0x3));
+            // secLow32
+            view.setUint32(4, secLow);
+            return rv;
+        }
+    }
+    else {
+        // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+        var rv = new Uint8Array(12);
+        var view = new DataView(rv.buffer);
+        view.setUint32(0, nsec);
+        (0,_utils_int_mjs__WEBPACK_IMPORTED_MODULE_0__.setInt64)(view, 4, sec);
+        return rv;
+    }
+}
+function encodeDateToTimeSpec(date) {
+    var msec = date.getTime();
+    var sec = Math.floor(msec / 1e3);
+    var nsec = (msec - sec * 1e3) * 1e6;
+    // Normalizes { sec, nsec } to ensure nsec is unsigned.
+    var nsecInSec = Math.floor(nsec / 1e9);
+    return {
+        sec: sec + nsecInSec,
+        nsec: nsec - nsecInSec * 1e9,
+    };
+}
+function encodeTimestampExtension(object) {
+    if (object instanceof Date) {
+        var timeSpec = encodeDateToTimeSpec(object);
+        return encodeTimeSpecToTimestamp(timeSpec);
+    }
+    else {
+        return null;
+    }
+}
+function decodeTimestampToTimeSpec(data) {
+    var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    // data may be 32, 64, or 96 bits
+    switch (data.byteLength) {
+        case 4: {
+            // timestamp 32 = { sec32 }
+            var sec = view.getUint32(0);
+            var nsec = 0;
+            return { sec: sec, nsec: nsec };
+        }
+        case 8: {
+            // timestamp 64 = { nsec30, sec34 }
+            var nsec30AndSecHigh2 = view.getUint32(0);
+            var secLow32 = view.getUint32(4);
+            var sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;
+            var nsec = nsec30AndSecHigh2 >>> 2;
+            return { sec: sec, nsec: nsec };
+        }
+        case 12: {
+            // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+            var sec = (0,_utils_int_mjs__WEBPACK_IMPORTED_MODULE_0__.getInt64)(view, 4);
+            var nsec = view.getUint32(0);
+            return { sec: sec, nsec: nsec };
+        }
+        default:
+            throw new _DecodeError_mjs__WEBPACK_IMPORTED_MODULE_1__.DecodeError("Unrecognized data size for timestamp (expected 4, 8, or 12): ".concat(data.length));
+    }
+}
+function decodeTimestampExtension(data) {
+    var timeSpec = decodeTimestampToTimeSpec(data);
+    return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+}
+var timestampExtension = {
+    type: EXT_TIMESTAMP,
+    encode: encodeTimestampExtension,
+    decode: decodeTimestampExtension,
+};
+//# sourceMappingURL=timestamp.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs":
+/*!******************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs ***!
+  \******************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   UINT32_MAX: () => (/* binding */ UINT32_MAX),
+/* harmony export */   getInt64: () => (/* binding */ getInt64),
+/* harmony export */   getUint64: () => (/* binding */ getUint64),
+/* harmony export */   setInt64: () => (/* binding */ setInt64),
+/* harmony export */   setUint64: () => (/* binding */ setUint64)
+/* harmony export */ });
+// Integer Utility
+var UINT32_MAX = 4294967295;
+// DataView extension to handle int64 / uint64,
+// where the actual range is 53-bits integer (a.k.a. safe integer)
+function setUint64(view, offset, value) {
+    var high = value / 4294967296;
+    var low = value; // high bits are truncated by DataView
+    view.setUint32(offset, high);
+    view.setUint32(offset + 4, low);
+}
+function setInt64(view, offset, value) {
+    var high = Math.floor(value / 4294967296);
+    var low = value; // high bits are truncated by DataView
+    view.setUint32(offset, high);
+    view.setUint32(offset + 4, low);
+}
+function getInt64(view, offset) {
+    var high = view.getInt32(offset);
+    var low = view.getUint32(offset + 4);
+    return high * 4294967296 + low;
+}
+function getUint64(view, offset) {
+    var high = view.getUint32(offset);
+    var low = view.getUint32(offset + 4);
+    return high * 4294967296 + low;
+}
+//# sourceMappingURL=int.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/prettyByte.mjs":
+/*!*************************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/utils/prettyByte.mjs ***!
+  \*************************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   prettyByte: () => (/* binding */ prettyByte)
+/* harmony export */ });
+function prettyByte(byte) {
+    return "".concat(byte < 0 ? "-" : "", "0x").concat(Math.abs(byte).toString(16).padStart(2, "0"));
+}
+//# sourceMappingURL=prettyByte.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/typedArrays.mjs":
+/*!**************************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/utils/typedArrays.mjs ***!
+  \**************************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   createDataView: () => (/* binding */ createDataView),
+/* harmony export */   ensureUint8Array: () => (/* binding */ ensureUint8Array)
+/* harmony export */ });
+function ensureUint8Array(buffer) {
+    if (buffer instanceof Uint8Array) {
+        return buffer;
+    }
+    else if (ArrayBuffer.isView(buffer)) {
+        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    else if (buffer instanceof ArrayBuffer) {
+        return new Uint8Array(buffer);
+    }
+    else {
+        // ArrayLike<number>
+        return Uint8Array.from(buffer);
+    }
+}
+function createDataView(buffer) {
+    if (buffer instanceof ArrayBuffer) {
+        return new DataView(buffer);
+    }
+    var bufferView = ensureUint8Array(buffer);
+    return new DataView(bufferView.buffer, bufferView.byteOffset, bufferView.byteLength);
+}
+//# sourceMappingURL=typedArrays.mjs.map
+
+/***/ }),
+
+/***/ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs":
+/*!*******************************************************************!*\
+  !*** ./node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs ***!
+  \*******************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   TEXT_DECODER_THRESHOLD: () => (/* binding */ TEXT_DECODER_THRESHOLD),
+/* harmony export */   TEXT_ENCODER_THRESHOLD: () => (/* binding */ TEXT_ENCODER_THRESHOLD),
+/* harmony export */   utf8Count: () => (/* binding */ utf8Count),
+/* harmony export */   utf8DecodeJs: () => (/* binding */ utf8DecodeJs),
+/* harmony export */   utf8DecodeTD: () => (/* binding */ utf8DecodeTD),
+/* harmony export */   utf8EncodeJs: () => (/* binding */ utf8EncodeJs),
+/* harmony export */   utf8EncodeTE: () => (/* binding */ utf8EncodeTE)
+/* harmony export */ });
+/* harmony import */ var _int_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./int.mjs */ "./node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs");
+var _a, _b, _c;
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+
+var TEXT_ENCODING_AVAILABLE = (typeof process === "undefined" || ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a["TEXT_ENCODING"]) !== "never") &&
+    typeof TextEncoder !== "undefined" &&
+    typeof TextDecoder !== "undefined";
+function utf8Count(str) {
+    var strLength = str.length;
+    var byteLength = 0;
+    var pos = 0;
+    while (pos < strLength) {
+        var value = str.charCodeAt(pos++);
+        if ((value & 0xffffff80) === 0) {
+            // 1-byte
+            byteLength++;
+            continue;
+        }
+        else if ((value & 0xfffff800) === 0) {
+            // 2-bytes
+            byteLength += 2;
+        }
+        else {
+            // handle surrogate pair
+            if (value >= 0xd800 && value <= 0xdbff) {
+                // high surrogate
+                if (pos < strLength) {
+                    var extra = str.charCodeAt(pos);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        ++pos;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+            }
+            if ((value & 0xffff0000) === 0) {
+                // 3-byte
+                byteLength += 3;
+            }
+            else {
+                // 4-byte
+                byteLength += 4;
+            }
+        }
+    }
+    return byteLength;
+}
+function utf8EncodeJs(str, output, outputOffset) {
+    var strLength = str.length;
+    var offset = outputOffset;
+    var pos = 0;
+    while (pos < strLength) {
+        var value = str.charCodeAt(pos++);
+        if ((value & 0xffffff80) === 0) {
+            // 1-byte
+            output[offset++] = value;
+            continue;
+        }
+        else if ((value & 0xfffff800) === 0) {
+            // 2-bytes
+            output[offset++] = ((value >> 6) & 0x1f) | 0xc0;
+        }
+        else {
+            // handle surrogate pair
+            if (value >= 0xd800 && value <= 0xdbff) {
+                // high surrogate
+                if (pos < strLength) {
+                    var extra = str.charCodeAt(pos);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        ++pos;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+            }
+            if ((value & 0xffff0000) === 0) {
+                // 3-byte
+                output[offset++] = ((value >> 12) & 0x0f) | 0xe0;
+                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+            }
+            else {
+                // 4-byte
+                output[offset++] = ((value >> 18) & 0x07) | 0xf0;
+                output[offset++] = ((value >> 12) & 0x3f) | 0x80;
+                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+            }
+        }
+        output[offset++] = (value & 0x3f) | 0x80;
+    }
+}
+var sharedTextEncoder = TEXT_ENCODING_AVAILABLE ? new TextEncoder() : undefined;
+var TEXT_ENCODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
+    ? _int_mjs__WEBPACK_IMPORTED_MODULE_0__.UINT32_MAX
+    : typeof process !== "undefined" && ((_b = process === null || process === void 0 ? void 0 : process.env) === null || _b === void 0 ? void 0 : _b["TEXT_ENCODING"]) !== "force"
+        ? 200
+        : 0;
+function utf8EncodeTEencode(str, output, outputOffset) {
+    output.set(sharedTextEncoder.encode(str), outputOffset);
+}
+function utf8EncodeTEencodeInto(str, output, outputOffset) {
+    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+}
+var utf8EncodeTE = (sharedTextEncoder === null || sharedTextEncoder === void 0 ? void 0 : sharedTextEncoder.encodeInto) ? utf8EncodeTEencodeInto : utf8EncodeTEencode;
+var CHUNK_SIZE = 4096;
+function utf8DecodeJs(bytes, inputOffset, byteLength) {
+    var offset = inputOffset;
+    var end = offset + byteLength;
+    var units = [];
+    var result = "";
+    while (offset < end) {
+        var byte1 = bytes[offset++];
+        if ((byte1 & 0x80) === 0) {
+            // 1 byte
+            units.push(byte1);
+        }
+        else if ((byte1 & 0xe0) === 0xc0) {
+            // 2 bytes
+            var byte2 = bytes[offset++] & 0x3f;
+            units.push(((byte1 & 0x1f) << 6) | byte2);
+        }
+        else if ((byte1 & 0xf0) === 0xe0) {
+            // 3 bytes
+            var byte2 = bytes[offset++] & 0x3f;
+            var byte3 = bytes[offset++] & 0x3f;
+            units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
+        }
+        else if ((byte1 & 0xf8) === 0xf0) {
+            // 4 bytes
+            var byte2 = bytes[offset++] & 0x3f;
+            var byte3 = bytes[offset++] & 0x3f;
+            var byte4 = bytes[offset++] & 0x3f;
+            var unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
+            if (unit > 0xffff) {
+                unit -= 0x10000;
+                units.push(((unit >>> 10) & 0x3ff) | 0xd800);
+                unit = 0xdc00 | (unit & 0x3ff);
+            }
+            units.push(unit);
+        }
+        else {
+            units.push(byte1);
+        }
+        if (units.length >= CHUNK_SIZE) {
+            result += String.fromCharCode.apply(String, units);
+            units.length = 0;
+        }
+    }
+    if (units.length > 0) {
+        result += String.fromCharCode.apply(String, units);
+    }
+    return result;
+}
+var sharedTextDecoder = TEXT_ENCODING_AVAILABLE ? new TextDecoder() : null;
+var TEXT_DECODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
+    ? _int_mjs__WEBPACK_IMPORTED_MODULE_0__.UINT32_MAX
+    : typeof process !== "undefined" && ((_c = process === null || process === void 0 ? void 0 : process.env) === null || _c === void 0 ? void 0 : _c["TEXT_DECODER"]) !== "force"
+        ? 200
+        : 0;
+function utf8DecodeTD(bytes, inputOffset, byteLength) {
+    var stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+    return sharedTextDecoder.decode(stringBytes);
+}
+//# sourceMappingURL=utf8.mjs.map
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+/*!*********************************!*\
+  !*** ./src/websocket-client.js ***!
+  \*********************************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   API_VERSION: () => (/* reexport safe */ _rpc_js__WEBPACK_IMPORTED_MODULE_0__.API_VERSION),
+/* harmony export */   RPC: () => (/* reexport safe */ _rpc_js__WEBPACK_IMPORTED_MODULE_0__.RPC),
+/* harmony export */   connectToServer: () => (/* binding */ connectToServer),
+/* harmony export */   getRTCService: () => (/* reexport safe */ _webrtc_client_js__WEBPACK_IMPORTED_MODULE_2__.getRTCService),
+/* harmony export */   loadRequirements: () => (/* reexport safe */ _utils_js__WEBPACK_IMPORTED_MODULE_1__.loadRequirements),
+/* harmony export */   login: () => (/* binding */ login),
+/* harmony export */   registerRTCService: () => (/* reexport safe */ _webrtc_client_js__WEBPACK_IMPORTED_MODULE_2__.registerRTCService),
+/* harmony export */   setupLocalClient: () => (/* binding */ setupLocalClient)
+/* harmony export */ });
+/* harmony import */ var _rpc_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./rpc.js */ "./src/rpc.js");
+/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils.js */ "./src/utils.js");
+/* harmony import */ var _webrtc_client_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./webrtc-client.js */ "./src/webrtc-client.js");
+
+
+
+
+
+
+
+
+const MAX_RETRY = 10000;
+
+class WebsocketRPCConnection {
+  constructor(
+    server_url,
+    client_id,
+    workspace,
+    token,
+    timeout = 60,
+    WebSocketClass = null,
+  ) {
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(server_url && client_id, "server_url and client_id are required");
+    this._server_url = server_url;
+    this._client_id = client_id;
+    this._workspace = workspace;
+    this._token = token;
+    this._reconnection_token = null;
+    this._websocket = null;
+    this._handle_message = null;
+    this._handle_connect = null; // Connection open event handler
+    this._disconnect_handler = null; // Disconnection event handler
+    this._timeout = timeout * 1000; // Convert seconds to milliseconds
+    this._WebSocketClass = WebSocketClass || WebSocket; // Allow overriding the WebSocket class
+    this._closing = false;
+    this._legacy_auth = null;
+    this.connection_info = null;
+  }
+
+  on_message(handler) {
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(handler, "handler is required");
+    this._handle_message = handler;
+  }
+
+  on_connect(handler) {
+    this._handle_connect = handler;
+  }
+
+  on_disconnected(handler) {
+    this._disconnect_handler = handler;
+  }
+
+  async _attempt_connection(server_url, attempt_fallback = true) {
+    return new Promise((resolve, reject) => {
+      this._legacy_auth = false;
+      const websocket = new this._WebSocketClass(server_url);
+      websocket.binaryType = "arraybuffer";
+
+      websocket.onopen = () => {
+        console.info("WebSocket connection established");
+        resolve(websocket);
+      };
+
+      websocket.onerror = (event) => {
+        console.error("WebSocket connection error:", event);
+        reject(event);
+      };
+
+      websocket.onclose = (event) => {
+        if (event.code === 1003 && attempt_fallback) {
+          console.info(
+            "Received 1003 error, attempting connection with query parameters.",
+          );
+          this._attempt_connection_with_query_params(server_url)
+            .then(resolve)
+            .catch(reject);
+        } else if (this._disconnect_handler) {
+          this._disconnect_handler(this, event.reason);
+        }
+      };
+    });
+  }
+
+  async _attempt_connection_with_query_params(server_url) {
+    // Initialize an array to hold parts of the query string
+    const queryParamsParts = [];
+
+    // Conditionally add each parameter if it has a non-empty value
+    if (this._client_id)
+      queryParamsParts.push(`client_id=${encodeURIComponent(this._client_id)}`);
+    if (this._workspace)
+      queryParamsParts.push(`workspace=${encodeURIComponent(this._workspace)}`);
+    if (this._token)
+      queryParamsParts.push(`token=${encodeURIComponent(this._token)}`);
+    if (this._reconnection_token)
+      queryParamsParts.push(
+        `reconnection_token=${encodeURIComponent(this._reconnection_token)}`,
+      );
+
+    // Join the parts with '&' to form the final query string, prepend '?' if there are any parameters
+    const queryString =
+      queryParamsParts.length > 0 ? `?${queryParamsParts.join("&")}` : "";
+
+    // Construct the full URL by appending the query string if it exists
+    const full_url = server_url + queryString;
+
+    this._legacy_auth = true; // Assuming this flag is needed for some other logic
+    return await this._attempt_connection(full_url, false);
+  }
+
+  async open() {
+    if (this._closing || this._websocket) {
+      return; // Avoid opening a new connection if closing or already open
+    }
+    try {
+      this._websocket = await this._attempt_connection(this._server_url);
+      if (!this._legacy_auth) {
+        // Send authentication info as the first message if connected without query params
+        const authInfo = JSON.stringify({
+          client_id: this._client_id,
+          workspace: this._workspace,
+          token: this._token,
+          reconnection_token: this._reconnection_token,
+        });
+        this._websocket.send(authInfo);
+        // Wait for the first message from the server
+        await (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.waitFor)(
+          new Promise((resolve, reject) => {
+            this._websocket.onmessage = (event) => {
+              const data = event.data;
+              const first_message = JSON.parse(data);
+              if (!first_message.success) {
+                const error = first_message.error || "Unknown error";
+                console.error("Failed to connect, " + error);
+                this.connection_info = null;
+                reject(new Error(error));
+              } else if (first_message) {
+                console.log(
+                  "Successfully connected: " + JSON.stringify(first_message),
+                );
+                this.connection_info = first_message;
+                if(this.connection_info.reconnection_token) {
+                  this._reconnection_token = this.connection_info.reconnection_token;
+                };
+              }
+              resolve();
+            };
+          }),
+          this._timeout / 1000.0,
+          "Failed to receive the first message from the server",
+        );
+      }
+
+      this._websocket.onmessage = (event) => {
+        this._handle_message(event.data);
+      };
+
+      if (this._handle_connect) {
+        await this._handle_connect(this);
+      }
+    } catch (error) {
+      console.error("Failed to connect to", this._server_url, error);
+    }
+  }
+
+  async emit_message(data) {
+    if (this._closing) {
+      throw new Error("Connection is closing");
+    }
+    if (!this._websocket || this._websocket.readyState !== WebSocket.OPEN) {
+      await this.open();
+    }
+    try {
+      this._websocket.send(data);
+    } catch (exp) {
+      console.error(`Failed to send data, error: ${exp}`);
+      throw exp;
+    }
+  }
+
+  disconnect(reason) {
+    this._closing = true;
+    if (this._websocket && this._websocket.readyState === WebSocket.OPEN) {
+      this._websocket.close(1000, reason);
+      console.info(`WebSocket connection disconnected (${reason})`);
+    }
+  }
+}
+
+function normalizeServerUrl(server_url) {
+  if (!server_url) throw new Error("server_url is required");
+  if (server_url.startsWith("http://")) {
+    server_url =
+      server_url.replace("http://", "ws://").replace(/\/$/, "") + "/ws";
+  } else if (server_url.startsWith("https://")) {
+    server_url =
+      server_url.replace("https://", "wss://").replace(/\/$/, "") + "/ws";
+  }
+  return server_url;
+}
+
+async function login(config) {
+  const service_id = config.login_service_id || "public/*:hypha-login";
+  const timeout = config.login_timeout || 60;
+  const callback = config.login_callback;
+
+  const server = await connectToServer({
+    name: "initial login client",
+    server_url: config.server_url,
+  });
+  try {
+    const svc = await server.get_service(service_id);
+    const context = await svc.start();
+    if (callback) {
+      await callback(context);
+    } else {
+      console.log(`Please open your browser and login at ${context.login_url}`);
+    }
+    return await svc.check(context.key, timeout);
+  } catch (error) {
+    throw error;
+  } finally {
+    await server.disconnect();
+  }
+}
+
+async function connectToServer(config) {
+  if (config.server) {
+    config.server_url = config.server_url || config.server.url;
+    config.WebSocketClass =
+      config.WebSocketClass || config.server.WebSocketClass;
+  }
+  let clientId = config.client_id;
+  if (!clientId) {
+    clientId = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.randId)();
+    config.client_id = clientId;
+  }
+
+  let server_url = normalizeServerUrl(config.server_url);
+
+  let connection = new WebsocketRPCConnection(
+    server_url,
+    clientId,
+    config.workspace,
+    config.token,
+    config.method_timeout || 60,
+    config.WebSocketClass,
+  );
+  await connection.open();
+  (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(connection.connection_info, "Failed to connect to the server");
+  if(config.workspace && connection.connection_info.workspace !== config.workspace) {
+    throw new Error(`Connected to the wrong workspace: ${connection.connection_info.workspace}, expected: ${config.workspace}`);
+  }
+  const workspace = connection.connection_info.workspace;
+  const manager_id = connection.connection_info.manager_id;
+  const rpc = new _rpc_js__WEBPACK_IMPORTED_MODULE_0__.RPC(connection, {
+    client_id: clientId,
+    workspace,
+    manager_id,
+    default_context: { connection_type: "websocket" },
+    name: config.name,
+    method_timeout: config.method_timeout,
+    app_id: config.app_id,
+  });
+  const wm = await rpc.get_manager_service();
+  wm.rpc = rpc;
+
+  async function _export(api) {
+    api.id = "default";
+    api.name = api.name || config.name || api.id;
+    api.description = api.description || config.description;
+    await rpc.register_service(api, true);
+  }
+
+  async function getPlugin(query) {
+    return await wm.get_service(query + ":default");
+  }
+
+  async function disconnect() {
+    await rpc.disconnect();
+    await connection.disconnect();
+  }
+  if(connection.connection_info){
+    wm.config = Object.assign(wm.config, connection.connection_info);
+  }
+  wm.export = _export;
+  wm.getPlugin = getPlugin;
+  wm.listPlugins = wm.listServices;
+  wm.disconnect = disconnect;
+  wm.registerCodec = rpc.register_codec.bind(rpc);
+  wm.emit = rpc.emit;
+  wm.on = rpc.on;
+  if (rpc.manager_id) {
+    rpc.on("force-exit", async (message) => {
+      if (message.from === "*/" + rpc.manager_id) {
+        console.log("Disconnecting from server, reason:", message.reason);
+        await disconnect();
+      }
+    });
+  }
+  if (config.webrtc) {
+    await (0,_webrtc_client_js__WEBPACK_IMPORTED_MODULE_2__.registerRTCService)(wm, clientId + "-rtc", config.webrtc_config);
+  }
+  if (wm.get_service || wm.getService) {
+    const _get_service = wm.get_service || wm.getService;
+    wm.get_service = async function (query, webrtc, webrtc_config) {
+      (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(
+        [undefined, true, false, "auto"].includes(webrtc),
+        "webrtc must be true, false or 'auto'",
+      );
+      const svc = await _get_service(query);
+      if (webrtc === true || webrtc === "auto") {
+        if (svc.id.includes(":") && svc.id.includes("/")) {
+          const client = svc.id.split(":")[0];
+          try {
+            // Assuming that the client registered a webrtc service with the client_id + "-rtc"
+            const peer = await (0,_webrtc_client_js__WEBPACK_IMPORTED_MODULE_2__.getRTCService)(
+              wm,
+              client + ":" + client.split("/")[1] + "-rtc",
+              webrtc_config,
+            );
+            const rtcSvc = await peer.get_service(svc.id.split(":")[1]);
+            rtcSvc._webrtc = true;
+            rtcSvc._peer = peer;
+            rtcSvc._service = svc;
+            return rtcSvc;
+          } catch (e) {
+            console.warn(
+              "Failed to get webrtc service, using websocket connection",
+              e,
+            );
+          }
+        }
+        if (webrtc === true) {
+          throw new Error("Failed to get the service via webrtc");
+        }
+      }
+      return svc;
+    };
+    wm.getService = wm.get_service;
+  }
+  return wm;
+}
+
+class LocalWebSocket {
+  constructor(url, client_id, workspace) {
+    this.url = url;
+    this.onopen = () => {};
+    this.onmessage = () => {};
+    this.onclose = () => {};
+    this.onerror = () => {};
+    this.client_id = client_id;
+    this.workspace = workspace;
+    const context = typeof window !== "undefined" ? window : self;
+    const isWindow = typeof window !== "undefined";
+    this.postMessage = (message) => {
+      if (isWindow) {
+        window.parent.postMessage(message, "*");
+      } else {
+        self.postMessage(message);
+      }
+    };
+
+    this.readyState = WebSocket.CONNECTING;
+    context.addEventListener(
+      "message",
+      (event) => {
+        const { type, data, to } = event.data;
+        if (to !== this.client_id) {
+          console.debug("message not for me", to, this.client_id);
+          return;
+        }
+        switch (type) {
+          case "message":
+            if (this.readyState === WebSocket.OPEN && this.onmessage) {
+              this.onmessage({ data: data });
+            }
+            break;
+          case "connected":
+            this.readyState = WebSocket.OPEN;
+            this.onopen(event);
+            break;
+          case "closed":
+            this.readyState = WebSocket.CLOSED;
+            this.onclose(event);
+            break;
+          default:
+            break;
+        }
+      },
+      false,
+    );
+
+    if (!this.client_id) throw new Error("client_id is required");
+    if (!this.workspace) throw new Error("workspace is required");
+    this.postMessage({
+      type: "connect",
+      url: this.url,
+      from: this.client_id,
+      workspace: this.workspace,
+    });
+  }
+
+  send(data) {
+    if (this.readyState === WebSocket.OPEN) {
+      this.postMessage({
+        type: "message",
+        data: data,
+        from: this.client_id,
+        workspace: this.workspace,
+      });
+    }
+  }
+
+  close() {
+    this.readyState = WebSocket.CLOSING;
+    this.postMessage({
+      type: "close",
+      from: this.client_id,
+      workspace: this.workspace,
+    });
+    this.onclose();
+  }
+
+  addEventListener(type, listener) {
+    if (type === "message") {
+      this.onmessage = listener;
+    }
+    if (type === "open") {
+      this.onopen = listener;
+    }
+    if (type === "close") {
+      this.onclose = listener;
+    }
+    if (type === "error") {
+      this.onerror = listener;
+    }
+  }
+}
+
+function setupLocalClient({
+  enable_execution = false,
+  on_ready = null,
+}) {
+  return new Promise((resolve, reject) => {
+    const context = typeof window !== "undefined" ? window : self;
+    const isWindow = typeof window !== "undefined";
+    context.addEventListener(
+      "message",
+      (event) => {
+        const {
+          type,
+          server_url,
+          workspace,
+          client_id,
+          token,
+          method_timeout,
+          name,
+          config,
+        } = event.data;
+
+        if (type === "initializeHyphaClient") {
+          if (!server_url || !workspace || !client_id) {
+            console.error("server_url, workspace, and client_id are required.");
+            return;
+          }
+
+          if (!server_url.startsWith("https://local-hypha-server:")) {
+            console.error(
+              "server_url should start with https://local-hypha-server:",
+            );
+            return;
+          }
+
+          connectToServer({
+            server_url,
+            workspace,
+            client_id,
+            token,
+            method_timeout,
+            name,
+          }).then(async (server) => {
+            globalThis.api = server;
+            try {
+              // for iframe
+              if (isWindow && enable_execution) {
+                function loadScript(script) {
+                  return new Promise((resolve, reject) => {
+                    const scriptElement = document.createElement("script");
+                    scriptElement.innerHTML = script.content;
+                    scriptElement.lang = script.lang;
+
+                    scriptElement.onload = () => resolve();
+                    scriptElement.onerror = (e) => reject(e);
+
+                    document.head.appendChild(scriptElement);
+                  });
+                }
+                if (config.styles && config.styles.length > 0) {
+                  for (const style of config.styles) {
+                    const styleElement = document.createElement("style");
+                    styleElement.innerHTML = style.content;
+                    styleElement.lang = style.lang;
+                    document.head.appendChild(styleElement);
+                  }
+                }
+                if (config.links && config.links.length > 0) {
+                  for (const link of config.links) {
+                    const linkElement = document.createElement("a");
+                    linkElement.href = link.url;
+                    linkElement.innerText = link.text;
+                    document.body.appendChild(linkElement);
+                  }
+                }
+                if (config.windows && config.windows.length > 0) {
+                  for (const w of config.windows) {
+                    document.body.innerHTML = w.content;
+                    break;
+                  }
+                }
+                if (config.scripts && config.scripts.length > 0) {
+                  for (const script of config.scripts) {
+                    if (script.lang !== "javascript")
+                      throw new Error("Only javascript scripts are supported");
+                    await loadScript(script); // Await the loading of each script
+                  }
+                }
+              }
+              // for web worker
+              else if (
+                !isWindow &&
+                enable_execution &&
+                config.scripts &&
+                config.scripts.length > 0
+              ) {
+                for (const script of config.scripts) {
+                  if (script.lang !== "javascript")
+                    throw new Error("Only javascript scripts are supported");
+                  eval(script.content);
+                }
+              }
+
+              if (on_ready) {
+                await on_ready(server, config);
+              }
+              resolve(server);
+            } catch (e) {
+              reject(e);
+            }
+          });
+        }
+      },
+      false,
+    );
+    if (isWindow) {
+      window.parent.postMessage({ type: "hyphaClientReady" }, "*");
+    } else {
+      self.postMessage({ type: "hyphaClientReady" });
+    }
+  });
+}
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
+//# sourceMappingURL=hypha-rpc-websocket.js.map