c0ckp1t 1.0.0

package/js_ext/msgpack.mjs

@@ -0,0 +1,1612 @@
+// node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs
+function utf8Count(str) {
+  var strLength = str.length;
+  var byteLength = 0;
+  var pos = 0;
+  while (pos < strLength) {
+    var value = str.charCodeAt(pos++);
+    if ((value & 4294967168) === 0) {
+      byteLength++;
+      continue;
+    } else if ((value & 4294965248) === 0) {
+      byteLength += 2;
+    } else {
+      if (value >= 55296 && value <= 56319) {
+        if (pos < strLength) {
+          var extra = str.charCodeAt(pos);
+          if ((extra & 64512) === 56320) {
+            ++pos;
+            value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+          }
+        }
+      }
+      if ((value & 4294901760) === 0) {
+        byteLength += 3;
+      } else {
+        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 & 4294967168) === 0) {
+      output[offset++] = value;
+      continue;
+    } else if ((value & 4294965248) === 0) {
+      output[offset++] = value >> 6 & 31 | 192;
+    } else {
+      if (value >= 55296 && value <= 56319) {
+        if (pos < strLength) {
+          var extra = str.charCodeAt(pos);
+          if ((extra & 64512) === 56320) {
+            ++pos;
+            value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+          }
+        }
+      }
+      if ((value & 4294901760) === 0) {
+        output[offset++] = value >> 12 & 15 | 224;
+        output[offset++] = value >> 6 & 63 | 128;
+      } else {
+        output[offset++] = value >> 18 & 7 | 240;
+        output[offset++] = value >> 12 & 63 | 128;
+        output[offset++] = value >> 6 & 63 | 128;
+      }
+    }
+    output[offset++] = value & 63 | 128;
+  }
+}
+var sharedTextEncoder = new TextEncoder();
+var TEXT_ENCODER_THRESHOLD = 50;
+function utf8EncodeTE(str, output, outputOffset) {
+  sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+}
+function utf8Encode(str, output, outputOffset) {
+  if (str.length > TEXT_ENCODER_THRESHOLD) {
+    utf8EncodeTE(str, output, outputOffset);
+  } else {
+    utf8EncodeJs(str, output, outputOffset);
+  }
+}
+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 & 128) === 0) {
+      units.push(byte1);
+    } else if ((byte1 & 224) === 192) {
+      var byte2 = bytes[offset++] & 63;
+      units.push((byte1 & 31) << 6 | byte2);
+    } else if ((byte1 & 240) === 224) {
+      var byte2 = bytes[offset++] & 63;
+      var byte3 = bytes[offset++] & 63;
+      units.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
+    } else if ((byte1 & 248) === 240) {
+      var byte2 = bytes[offset++] & 63;
+      var byte3 = bytes[offset++] & 63;
+      var byte4 = bytes[offset++] & 63;
+      var unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+      if (unit > 65535) {
+        unit -= 65536;
+        units.push(unit >>> 10 & 1023 | 55296);
+        unit = 56320 | unit & 1023;
+      }
+      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 = new TextDecoder();
+var TEXT_DECODER_THRESHOLD = 200;
+function utf8DecodeTD(bytes, inputOffset, byteLength) {
+  var stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+  return sharedTextDecoder.decode(stringBytes);
+}
+function utf8Decode(bytes, inputOffset, byteLength) {
+  if (byteLength > TEXT_DECODER_THRESHOLD) {
+    return utf8DecodeTD(bytes, inputOffset, byteLength);
+  } else {
+    return utf8DecodeJs(bytes, inputOffset, byteLength);
+  }
+}
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/ExtData.mjs
+var ExtData = (
+  /** @class */
+  function() {
+    function ExtData2(type, data) {
+      this.type = type;
+      this.data = data;
+    }
+    return ExtData2;
+  }()
+);
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/DecodeError.mjs
+var __extends = function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2)
+        if (Object.prototype.hasOwnProperty.call(b2, p))
+          d2[p] = b2[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(DecodeError2, _super);
+    function DecodeError2(message) {
+      var _this = _super.call(this, message) || this;
+      var proto = Object.create(DecodeError2.prototype);
+      Object.setPrototypeOf(_this, proto);
+      Object.defineProperty(_this, "name", {
+        configurable: true,
+        enumerable: false,
+        value: DecodeError2.name
+      });
+      return _this;
+    }
+    return DecodeError2;
+  }(Error)
+);
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/utils/int.mjs
+var UINT32_MAX = 4294967295;
+function setUint64(view, offset, value) {
+  var high = value / 4294967296;
+  var low = value;
+  view.setUint32(offset, high);
+  view.setUint32(offset + 4, low);
+}
+function setInt64(view, offset, value) {
+  var high = Math.floor(value / 4294967296);
+  var low = value;
+  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;
+}
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/timestamp.mjs
+var EXT_TIMESTAMP = -1;
+var TIMESTAMP32_MAX_SEC = 4294967296 - 1;
+var TIMESTAMP64_MAX_SEC = 17179869184 - 1;
+function encodeTimeSpecToTimestamp(_a) {
+  var sec = _a.sec, nsec = _a.nsec;
+  if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+    if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+      var rv = new Uint8Array(4);
+      var view = new DataView(rv.buffer);
+      view.setUint32(0, sec);
+      return rv;
+    } else {
+      var secHigh = sec / 4294967296;
+      var secLow = sec & 4294967295;
+      var rv = new Uint8Array(8);
+      var view = new DataView(rv.buffer);
+      view.setUint32(0, nsec << 2 | secHigh & 3);
+      view.setUint32(4, secLow);
+      return rv;
+    }
+  } else {
+    var rv = new Uint8Array(12);
+    var view = new DataView(rv.buffer);
+    view.setUint32(0, nsec);
+    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;
+  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);
+  switch (data.byteLength) {
+    case 4: {
+      var sec = view.getUint32(0);
+      var nsec = 0;
+      return { sec, nsec };
+    }
+    case 8: {
+      var nsec30AndSecHigh2 = view.getUint32(0);
+      var secLow32 = view.getUint32(4);
+      var sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
+      var nsec = nsec30AndSecHigh2 >>> 2;
+      return { sec, nsec };
+    }
+    case 12: {
+      var sec = getInt64(view, 4);
+      var nsec = view.getUint32(0);
+      return { sec, nsec };
+    }
+    default:
+      throw new 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
+};
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/ExtensionCodec.mjs
+var ExtensionCodec = (
+  /** @class */
+  function() {
+    function ExtensionCodec2() {
+      this.builtInEncoders = [];
+      this.builtInDecoders = [];
+      this.encoders = [];
+      this.decoders = [];
+      this.register(timestampExtension);
+    }
+    ExtensionCodec2.prototype.register = function(_a) {
+      var type = _a.type, encode2 = _a.encode, decode2 = _a.decode;
+      if (type >= 0) {
+        this.encoders[type] = encode2;
+        this.decoders[type] = decode2;
+      } else {
+        var index = 1 + type;
+        this.builtInEncoders[index] = encode2;
+        this.builtInDecoders[index] = decode2;
+      }
+    };
+    ExtensionCodec2.prototype.tryToEncode = function(object, context) {
+      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(type, data);
+          }
+        }
+      }
+      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(type, data);
+          }
+        }
+      }
+      if (object instanceof ExtData) {
+        return object;
+      }
+      return null;
+    };
+    ExtensionCodec2.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 {
+        return new ExtData(type, data);
+      }
+    };
+    ExtensionCodec2.defaultCodec = new ExtensionCodec2();
+    return ExtensionCodec2;
+  }()
+);
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/utils/typedArrays.mjs
+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 {
+    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);
+}
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/Encoder.mjs
+var DEFAULT_MAX_DEPTH = 100;
+var DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+var Encoder = (
+  /** @class */
+  function() {
+    function Encoder2(options) {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      this.extensionCodec = (_a = options === null || options === void 0 ? void 0 : options.extensionCodec) !== null && _a !== void 0 ? _a : ExtensionCodec.defaultCodec;
+      this.context = options === null || options === void 0 ? void 0 : options.context;
+      this.useBigInt64 = (_b = options === null || options === void 0 ? void 0 : options.useBigInt64) !== null && _b !== void 0 ? _b : false;
+      this.maxDepth = (_c = options === null || options === void 0 ? void 0 : options.maxDepth) !== null && _c !== void 0 ? _c : DEFAULT_MAX_DEPTH;
+      this.initialBufferSize = (_d = options === null || options === void 0 ? void 0 : options.initialBufferSize) !== null && _d !== void 0 ? _d : DEFAULT_INITIAL_BUFFER_SIZE;
+      this.sortKeys = (_e = options === null || options === void 0 ? void 0 : options.sortKeys) !== null && _e !== void 0 ? _e : false;
+      this.forceFloat32 = (_f = options === null || options === void 0 ? void 0 : options.forceFloat32) !== null && _f !== void 0 ? _f : false;
+      this.ignoreUndefined = (_g = options === null || options === void 0 ? void 0 : options.ignoreUndefined) !== null && _g !== void 0 ? _g : false;
+      this.forceIntegerToFloat = (_h = options === null || options === void 0 ? void 0 : options.forceIntegerToFloat) !== null && _h !== void 0 ? _h : false;
+      this.pos = 0;
+      this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+      this.bytes = new Uint8Array(this.view.buffer);
+    }
+    Encoder2.prototype.reinitializeState = function() {
+      this.pos = 0;
+    };
+    Encoder2.prototype.encodeSharedRef = function(object) {
+      this.reinitializeState();
+      this.doEncode(object, 1);
+      return this.bytes.subarray(0, this.pos);
+    };
+    Encoder2.prototype.encode = function(object) {
+      this.reinitializeState();
+      this.doEncode(object, 1);
+      return this.bytes.slice(0, this.pos);
+    };
+    Encoder2.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") {
+        if (!this.forceIntegerToFloat) {
+          this.encodeNumber(object);
+        } else {
+          this.encodeNumberAsFloat(object);
+        }
+      } else if (typeof object === "string") {
+        this.encodeString(object);
+      } else if (this.useBigInt64 && typeof object === "bigint") {
+        this.encodeBigInt64(object);
+      } else {
+        this.encodeObject(object, depth);
+      }
+    };
+    Encoder2.prototype.ensureBufferSizeToWrite = function(sizeToWrite) {
+      var requiredSize = this.pos + sizeToWrite;
+      if (this.view.byteLength < requiredSize) {
+        this.resizeBuffer(requiredSize * 2);
+      }
+    };
+    Encoder2.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;
+    };
+    Encoder2.prototype.encodeNil = function() {
+      this.writeU8(192);
+    };
+    Encoder2.prototype.encodeBoolean = function(object) {
+      if (object === false) {
+        this.writeU8(194);
+      } else {
+        this.writeU8(195);
+      }
+    };
+    Encoder2.prototype.encodeNumber = function(object) {
+      if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+        if (object >= 0) {
+          if (object < 128) {
+            this.writeU8(object);
+          } else if (object < 256) {
+            this.writeU8(204);
+            this.writeU8(object);
+          } else if (object < 65536) {
+            this.writeU8(205);
+            this.writeU16(object);
+          } else if (object < 4294967296) {
+            this.writeU8(206);
+            this.writeU32(object);
+          } else if (!this.useBigInt64) {
+            this.writeU8(207);
+            this.writeU64(object);
+          } else {
+            this.encodeNumberAsFloat(object);
+          }
+        } else {
+          if (object >= -32) {
+            this.writeU8(224 | object + 32);
+          } else if (object >= -128) {
+            this.writeU8(208);
+            this.writeI8(object);
+          } else if (object >= -32768) {
+            this.writeU8(209);
+            this.writeI16(object);
+          } else if (object >= -2147483648) {
+            this.writeU8(210);
+            this.writeI32(object);
+          } else if (!this.useBigInt64) {
+            this.writeU8(211);
+            this.writeI64(object);
+          } else {
+            this.encodeNumberAsFloat(object);
+          }
+        }
+      } else {
+        this.encodeNumberAsFloat(object);
+      }
+    };
+    Encoder2.prototype.encodeNumberAsFloat = function(object) {
+      if (this.forceFloat32) {
+        this.writeU8(202);
+        this.writeF32(object);
+      } else {
+        this.writeU8(203);
+        this.writeF64(object);
+      }
+    };
+    Encoder2.prototype.encodeBigInt64 = function(object) {
+      if (object >= BigInt(0)) {
+        this.writeU8(207);
+        this.writeBigUint64(object);
+      } else {
+        this.writeU8(211);
+        this.writeBigInt64(object);
+      }
+    };
+    Encoder2.prototype.writeStringHeader = function(byteLength) {
+      if (byteLength < 32) {
+        this.writeU8(160 + byteLength);
+      } else if (byteLength < 256) {
+        this.writeU8(217);
+        this.writeU8(byteLength);
+      } else if (byteLength < 65536) {
+        this.writeU8(218);
+        this.writeU16(byteLength);
+      } else if (byteLength < 4294967296) {
+        this.writeU8(219);
+        this.writeU32(byteLength);
+      } else {
+        throw new Error("Too long string: ".concat(byteLength, " bytes in UTF-8"));
+      }
+    };
+    Encoder2.prototype.encodeString = function(object) {
+      var maxHeaderSize = 1 + 4;
+      var byteLength = utf8Count(object);
+      this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+      this.writeStringHeader(byteLength);
+      utf8Encode(object, this.bytes, this.pos);
+      this.pos += byteLength;
+    };
+    Encoder2.prototype.encodeObject = function(object, depth) {
+      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 {
+        throw new Error("Unrecognized object: ".concat(Object.prototype.toString.apply(object)));
+      }
+    };
+    Encoder2.prototype.encodeBinary = function(object) {
+      var size = object.byteLength;
+      if (size < 256) {
+        this.writeU8(196);
+        this.writeU8(size);
+      } else if (size < 65536) {
+        this.writeU8(197);
+        this.writeU16(size);
+      } else if (size < 4294967296) {
+        this.writeU8(198);
+        this.writeU32(size);
+      } else {
+        throw new Error("Too large binary: ".concat(size));
+      }
+      var bytes = ensureUint8Array(object);
+      this.writeU8a(bytes);
+    };
+    Encoder2.prototype.encodeArray = function(object, depth) {
+      var size = object.length;
+      if (size < 16) {
+        this.writeU8(144 + size);
+      } else if (size < 65536) {
+        this.writeU8(220);
+        this.writeU16(size);
+      } else if (size < 4294967296) {
+        this.writeU8(221);
+        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);
+      }
+    };
+    Encoder2.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] !== void 0) {
+          count++;
+        }
+      }
+      return count;
+    };
+    Encoder2.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) {
+        this.writeU8(128 + size);
+      } else if (size < 65536) {
+        this.writeU8(222);
+        this.writeU16(size);
+      } else if (size < 4294967296) {
+        this.writeU8(223);
+        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 === void 0)) {
+          this.encodeString(key);
+          this.doEncode(value, depth + 1);
+        }
+      }
+    };
+    Encoder2.prototype.encodeExtension = function(ext) {
+      var size = ext.data.length;
+      if (size === 1) {
+        this.writeU8(212);
+      } else if (size === 2) {
+        this.writeU8(213);
+      } else if (size === 4) {
+        this.writeU8(214);
+      } else if (size === 8) {
+        this.writeU8(215);
+      } else if (size === 16) {
+        this.writeU8(216);
+      } else if (size < 256) {
+        this.writeU8(199);
+        this.writeU8(size);
+      } else if (size < 65536) {
+        this.writeU8(200);
+        this.writeU16(size);
+      } else if (size < 4294967296) {
+        this.writeU8(201);
+        this.writeU32(size);
+      } else {
+        throw new Error("Too large extension object: ".concat(size));
+      }
+      this.writeI8(ext.type);
+      this.writeU8a(ext.data);
+    };
+    Encoder2.prototype.writeU8 = function(value) {
+      this.ensureBufferSizeToWrite(1);
+      this.view.setUint8(this.pos, value);
+      this.pos++;
+    };
+    Encoder2.prototype.writeU8a = function(values) {
+      var size = values.length;
+      this.ensureBufferSizeToWrite(size);
+      this.bytes.set(values, this.pos);
+      this.pos += size;
+    };
+    Encoder2.prototype.writeI8 = function(value) {
+      this.ensureBufferSizeToWrite(1);
+      this.view.setInt8(this.pos, value);
+      this.pos++;
+    };
+    Encoder2.prototype.writeU16 = function(value) {
+      this.ensureBufferSizeToWrite(2);
+      this.view.setUint16(this.pos, value);
+      this.pos += 2;
+    };
+    Encoder2.prototype.writeI16 = function(value) {
+      this.ensureBufferSizeToWrite(2);
+      this.view.setInt16(this.pos, value);
+      this.pos += 2;
+    };
+    Encoder2.prototype.writeU32 = function(value) {
+      this.ensureBufferSizeToWrite(4);
+      this.view.setUint32(this.pos, value);
+      this.pos += 4;
+    };
+    Encoder2.prototype.writeI32 = function(value) {
+      this.ensureBufferSizeToWrite(4);
+      this.view.setInt32(this.pos, value);
+      this.pos += 4;
+    };
+    Encoder2.prototype.writeF32 = function(value) {
+      this.ensureBufferSizeToWrite(4);
+      this.view.setFloat32(this.pos, value);
+      this.pos += 4;
+    };
+    Encoder2.prototype.writeF64 = function(value) {
+      this.ensureBufferSizeToWrite(8);
+      this.view.setFloat64(this.pos, value);
+      this.pos += 8;
+    };
+    Encoder2.prototype.writeU64 = function(value) {
+      this.ensureBufferSizeToWrite(8);
+      setUint64(this.view, this.pos, value);
+      this.pos += 8;
+    };
+    Encoder2.prototype.writeI64 = function(value) {
+      this.ensureBufferSizeToWrite(8);
+      setInt64(this.view, this.pos, value);
+      this.pos += 8;
+    };
+    Encoder2.prototype.writeBigUint64 = function(value) {
+      this.ensureBufferSizeToWrite(8);
+      this.view.setBigUint64(this.pos, value);
+      this.pos += 8;
+    };
+    Encoder2.prototype.writeBigInt64 = function(value) {
+      this.ensureBufferSizeToWrite(8);
+      this.view.setBigInt64(this.pos, value);
+      this.pos += 8;
+    };
+    return Encoder2;
+  }()
+);
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/encode.mjs
+function encode(value, options) {
+  var encoder = new Encoder(options);
+  return encoder.encodeSharedRef(value);
+}
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/utils/prettyByte.mjs
+function prettyByte(byte) {
+  return "".concat(byte < 0 ? "-" : "", "0x").concat(Math.abs(byte).toString(16).padStart(2, "0"));
+}
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/CachedKeyDecoder.mjs
+var DEFAULT_MAX_KEY_LENGTH = 16;
+var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+var CachedKeyDecoder = (
+  /** @class */
+  function() {
+    function CachedKeyDecoder2(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;
+      this.caches = [];
+      for (var i = 0; i < this.maxKeyLength; i++) {
+        this.caches.push([]);
+      }
+    }
+    CachedKeyDecoder2.prototype.canBeCached = function(byteLength) {
+      return byteLength > 0 && byteLength <= this.maxKeyLength;
+    };
+    CachedKeyDecoder2.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;
+    };
+    CachedKeyDecoder2.prototype.store = function(bytes, value) {
+      var records = this.caches[bytes.length - 1];
+      var record = { bytes, str: value };
+      if (records.length >= this.maxLengthPerKey) {
+        records[Math.random() * records.length | 0] = record;
+      } else {
+        records.push(record);
+      }
+    };
+    CachedKeyDecoder2.prototype.decode = function(bytes, inputOffset, byteLength) {
+      var cachedValue = this.find(bytes, inputOffset, byteLength);
+      if (cachedValue != null) {
+        this.hit++;
+        return cachedValue;
+      }
+      this.miss++;
+      var str = utf8DecodeJs(bytes, inputOffset, byteLength);
+      var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+      this.store(slicedCopyOfBytes, str);
+      return str;
+    };
+    return CachedKeyDecoder2;
+  }()
+);
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/Decoder.mjs
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = function(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1)
+      throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _)
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        if (y = 0, t)
+          op = [op[0] & 2, t.value];
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            _.label++;
+            return { value: op[1], done: false };
+          case 5:
+            _.label++;
+            y = op[1];
+            op = [0];
+            continue;
+          case 7:
+            op = _.ops.pop();
+            _.trys.pop();
+            continue;
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+              _.ops.push(op);
+              break;
+            }
+            if (t[2])
+              _.ops.pop();
+            _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+};
+var __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(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+};
+var __await = function(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+};
+var __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 STATE_ARRAY = "array";
+var STATE_MAP_KEY = "map_key";
+var STATE_MAP_VALUE = "map_value";
+var isValidMapKeyType = function(key) {
+  return typeof key === "string" || typeof key === "number";
+};
+var HEAD_BYTE_REQUIRED = -1;
+var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+try {
+  EMPTY_VIEW.getInt8(0);
+} catch (e) {
+  if (!(e instanceof RangeError)) {
+    throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+  }
+}
+var DataViewIndexOutOfBoundsError = RangeError;
+var MORE_DATA = new DataViewIndexOutOfBoundsError("Insufficient data");
+var sharedCachedKeyDecoder = new CachedKeyDecoder();
+var Decoder = (
+  /** @class */
+  function() {
+    function Decoder2(options) {
+      var _a, _b, _c, _d, _e, _f, _g;
+      this.totalPos = 0;
+      this.pos = 0;
+      this.view = EMPTY_VIEW;
+      this.bytes = EMPTY_BYTES;
+      this.headByte = HEAD_BYTE_REQUIRED;
+      this.stack = [];
+      this.extensionCodec = (_a = options === null || options === void 0 ? void 0 : options.extensionCodec) !== null && _a !== void 0 ? _a : ExtensionCodec.defaultCodec;
+      this.context = options === null || options === void 0 ? void 0 : options.context;
+      this.useBigInt64 = (_b = options === null || options === void 0 ? void 0 : options.useBigInt64) !== null && _b !== void 0 ? _b : false;
+      this.maxStrLength = (_c = options === null || options === void 0 ? void 0 : options.maxStrLength) !== null && _c !== void 0 ? _c : UINT32_MAX;
+      this.maxBinLength = (_d = options === null || options === void 0 ? void 0 : options.maxBinLength) !== null && _d !== void 0 ? _d : UINT32_MAX;
+      this.maxArrayLength = (_e = options === null || options === void 0 ? void 0 : options.maxArrayLength) !== null && _e !== void 0 ? _e : UINT32_MAX;
+      this.maxMapLength = (_f = options === null || options === void 0 ? void 0 : options.maxMapLength) !== null && _f !== void 0 ? _f : UINT32_MAX;
+      this.maxExtLength = (_g = options === null || options === void 0 ? void 0 : options.maxExtLength) !== null && _g !== void 0 ? _g : UINT32_MAX;
+      this.keyDecoder = (options === null || options === void 0 ? void 0 : options.keyDecoder) !== void 0 ? options.keyDecoder : sharedCachedKeyDecoder;
+    }
+    Decoder2.prototype.reinitializeState = function() {
+      this.totalPos = 0;
+      this.headByte = HEAD_BYTE_REQUIRED;
+      this.stack.length = 0;
+    };
+    Decoder2.prototype.setBuffer = function(buffer) {
+      this.bytes = ensureUint8Array(buffer);
+      this.view = createDataView(this.bytes);
+      this.pos = 0;
+    };
+    Decoder2.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 = ensureUint8Array(buffer);
+        var newBuffer = new Uint8Array(remainingData.length + newData.length);
+        newBuffer.set(remainingData);
+        newBuffer.set(newData, remainingData.length);
+        this.setBuffer(newBuffer);
+      }
+    };
+    Decoder2.prototype.hasRemaining = function(size) {
+      return this.view.byteLength - this.pos >= size;
+    };
+    Decoder2.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, "]"));
+    };
+    Decoder2.prototype.decode = function(buffer) {
+      this.reinitializeState();
+      this.setBuffer(buffer);
+      var object = this.doDecodeSync();
+      if (this.hasRemaining(1)) {
+        throw this.createExtraByteError(this.pos);
+      }
+      return object;
+    };
+    Decoder2.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, 3];
+            return [4, this.doDecodeSync()];
+          case 2:
+            _a.sent();
+            return [3, 1];
+          case 3:
+            return [
+              2
+              /*return*/
+            ];
+        }
+      });
+    };
+    Decoder2.prototype.decodeAsync = function(stream) {
+      var _a, stream_1, stream_1_1;
+      var _b, e_1, _c, _d;
+      return __awaiter(this, void 0, void 0, function() {
+        var decoded, object, buffer, e_1_1, _e, headByte, pos, totalPos;
+        return __generator(this, function(_f) {
+          switch (_f.label) {
+            case 0:
+              decoded = false;
+              _f.label = 1;
+            case 1:
+              _f.trys.push([1, 6, 7, 12]);
+              _a = true, stream_1 = __asyncValues(stream);
+              _f.label = 2;
+            case 2:
+              return [4, stream_1.next()];
+            case 3:
+              if (!(stream_1_1 = _f.sent(), _b = stream_1_1.done, !_b))
+                return [3, 5];
+              _d = stream_1_1.value;
+              _a = false;
+              try {
+                buffer = _d;
+                if (decoded) {
+                  throw this.createExtraByteError(this.totalPos);
+                }
+                this.appendBuffer(buffer);
+                try {
+                  object = this.doDecodeSync();
+                  decoded = true;
+                } catch (e) {
+                  if (!(e instanceof DataViewIndexOutOfBoundsError)) {
+                    throw e;
+                  }
+                }
+                this.totalPos += this.pos;
+              } finally {
+                _a = true;
+              }
+              _f.label = 4;
+            case 4:
+              return [3, 2];
+            case 5:
+              return [3, 12];
+            case 6:
+              e_1_1 = _f.sent();
+              e_1 = { error: e_1_1 };
+              return [3, 12];
+            case 7:
+              _f.trys.push([7, , 10, 11]);
+              if (!(!_a && !_b && (_c = stream_1.return)))
+                return [3, 9];
+              return [4, _c.call(stream_1)];
+            case 8:
+              _f.sent();
+              _f.label = 9;
+            case 9:
+              return [3, 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, object];
+              }
+              _e = this, headByte = _e.headByte, pos = _e.pos, totalPos = _e.totalPos;
+              throw new RangeError("Insufficient data in parsing ".concat(prettyByte(headByte), " at ").concat(totalPos, " (").concat(pos, " in the current buffer)"));
+          }
+        });
+      });
+    };
+    Decoder2.prototype.decodeArrayStream = function(stream) {
+      return this.decodeMultiAsync(stream, true);
+    };
+    Decoder2.prototype.decodeStream = function(stream) {
+      return this.decodeMultiAsync(stream, false);
+    };
+    Decoder2.prototype.decodeMultiAsync = function(stream, isArray) {
+      return __asyncGenerator(this, arguments, function decodeMultiAsync_1() {
+        var isArrayHeaderRequired, arrayItemsLeft, _a, stream_2, stream_2_1, buffer, e_2, e_3_1;
+        var _b, e_3, _c, _d;
+        return __generator(this, function(_e) {
+          switch (_e.label) {
+            case 0:
+              isArrayHeaderRequired = isArray;
+              arrayItemsLeft = -1;
+              _e.label = 1;
+            case 1:
+              _e.trys.push([1, 15, 16, 21]);
+              _a = true, stream_2 = __asyncValues(stream);
+              _e.label = 2;
+            case 2:
+              return [4, __await(stream_2.next())];
+            case 3:
+              if (!(stream_2_1 = _e.sent(), _b = stream_2_1.done, !_b))
+                return [3, 14];
+              _d = stream_2_1.value;
+              _a = false;
+              _e.label = 4;
+            case 4:
+              _e.trys.push([4, , 12, 13]);
+              buffer = _d;
+              if (isArray && arrayItemsLeft === 0) {
+                throw this.createExtraByteError(this.totalPos);
+              }
+              this.appendBuffer(buffer);
+              if (isArrayHeaderRequired) {
+                arrayItemsLeft = this.readArraySize();
+                isArrayHeaderRequired = false;
+                this.complete();
+              }
+              _e.label = 5;
+            case 5:
+              _e.trys.push([5, 10, , 11]);
+              _e.label = 6;
+            case 6:
+              if (false)
+                return [3, 9];
+              return [4, __await(this.doDecodeSync())];
+            case 7:
+              return [4, _e.sent()];
+            case 8:
+              _e.sent();
+              if (--arrayItemsLeft === 0) {
+                return [3, 9];
+              }
+              return [3, 6];
+            case 9:
+              return [3, 11];
+            case 10:
+              e_2 = _e.sent();
+              if (!(e_2 instanceof DataViewIndexOutOfBoundsError)) {
+                throw e_2;
+              }
+              return [3, 11];
+            case 11:
+              this.totalPos += this.pos;
+              return [3, 13];
+            case 12:
+              _a = true;
+              return [
+                7
+                /*endfinally*/
+              ];
+            case 13:
+              return [3, 2];
+            case 14:
+              return [3, 21];
+            case 15:
+              e_3_1 = _e.sent();
+              e_3 = { error: e_3_1 };
+              return [3, 21];
+            case 16:
+              _e.trys.push([16, , 19, 20]);
+              if (!(!_a && !_b && (_c = stream_2.return)))
+                return [3, 18];
+              return [4, __await(_c.call(stream_2))];
+            case 17:
+              _e.sent();
+              _e.label = 18;
+            case 18:
+              return [3, 20];
+            case 19:
+              if (e_3)
+                throw e_3.error;
+              return [
+                7
+                /*endfinally*/
+              ];
+            case 20:
+              return [
+                7
+                /*endfinally*/
+              ];
+            case 21:
+              return [
+                2
+                /*return*/
+              ];
+          }
+        });
+      });
+    };
+    Decoder2.prototype.doDecodeSync = function() {
+      DECODE:
+        while (true) {
+          var headByte = this.readHeadByte();
+          var object = void 0;
+          if (headByte >= 224) {
+            object = headByte - 256;
+          } else if (headByte < 192) {
+            if (headByte < 128) {
+              object = headByte;
+            } else if (headByte < 144) {
+              var size = headByte - 128;
+              if (size !== 0) {
+                this.pushMapState(size);
+                this.complete();
+                continue DECODE;
+              } else {
+                object = {};
+              }
+            } else if (headByte < 160) {
+              var size = headByte - 144;
+              if (size !== 0) {
+                this.pushArrayState(size);
+                this.complete();
+                continue DECODE;
+              } else {
+                object = [];
+              }
+            } else {
+              var byteLength = headByte - 160;
+              object = this.decodeUtf8String(byteLength, 0);
+            }
+          } else if (headByte === 192) {
+            object = null;
+          } else if (headByte === 194) {
+            object = false;
+          } else if (headByte === 195) {
+            object = true;
+          } else if (headByte === 202) {
+            object = this.readF32();
+          } else if (headByte === 203) {
+            object = this.readF64();
+          } else if (headByte === 204) {
+            object = this.readU8();
+          } else if (headByte === 205) {
+            object = this.readU16();
+          } else if (headByte === 206) {
+            object = this.readU32();
+          } else if (headByte === 207) {
+            if (this.useBigInt64) {
+              object = this.readU64AsBigInt();
+            } else {
+              object = this.readU64();
+            }
+          } else if (headByte === 208) {
+            object = this.readI8();
+          } else if (headByte === 209) {
+            object = this.readI16();
+          } else if (headByte === 210) {
+            object = this.readI32();
+          } else if (headByte === 211) {
+            if (this.useBigInt64) {
+              object = this.readI64AsBigInt();
+            } else {
+              object = this.readI64();
+            }
+          } else if (headByte === 217) {
+            var byteLength = this.lookU8();
+            object = this.decodeUtf8String(byteLength, 1);
+          } else if (headByte === 218) {
+            var byteLength = this.lookU16();
+            object = this.decodeUtf8String(byteLength, 2);
+          } else if (headByte === 219) {
+            var byteLength = this.lookU32();
+            object = this.decodeUtf8String(byteLength, 4);
+          } else if (headByte === 220) {
+            var size = this.readU16();
+            if (size !== 0) {
+              this.pushArrayState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = [];
+            }
+          } else if (headByte === 221) {
+            var size = this.readU32();
+            if (size !== 0) {
+              this.pushArrayState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = [];
+            }
+          } else if (headByte === 222) {
+            var size = this.readU16();
+            if (size !== 0) {
+              this.pushMapState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = {};
+            }
+          } else if (headByte === 223) {
+            var size = this.readU32();
+            if (size !== 0) {
+              this.pushMapState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = {};
+            }
+          } else if (headByte === 196) {
+            var size = this.lookU8();
+            object = this.decodeBinary(size, 1);
+          } else if (headByte === 197) {
+            var size = this.lookU16();
+            object = this.decodeBinary(size, 2);
+          } else if (headByte === 198) {
+            var size = this.lookU32();
+            object = this.decodeBinary(size, 4);
+          } else if (headByte === 212) {
+            object = this.decodeExtension(1, 0);
+          } else if (headByte === 213) {
+            object = this.decodeExtension(2, 0);
+          } else if (headByte === 214) {
+            object = this.decodeExtension(4, 0);
+          } else if (headByte === 215) {
+            object = this.decodeExtension(8, 0);
+          } else if (headByte === 216) {
+            object = this.decodeExtension(16, 0);
+          } else if (headByte === 199) {
+            var size = this.lookU8();
+            object = this.decodeExtension(size, 1);
+          } else if (headByte === 200) {
+            var size = this.lookU16();
+            object = this.decodeExtension(size, 2);
+          } else if (headByte === 201) {
+            var size = this.lookU32();
+            object = this.decodeExtension(size, 4);
+          } else {
+            throw new DecodeError("Unrecognized type byte: ".concat(prettyByte(headByte)));
+          }
+          this.complete();
+          var stack = this.stack;
+          while (stack.length > 0) {
+            var state = stack[stack.length - 1];
+            if (state.type === 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 === STATE_MAP_KEY) {
+              if (!isValidMapKeyType(object)) {
+                throw new DecodeError("The type of key must be string or number but " + typeof object);
+              }
+              if (object === "__proto__") {
+                throw new DecodeError("The key __proto__ is not allowed");
+              }
+              state.key = object;
+              state.type = STATE_MAP_VALUE;
+              continue DECODE;
+            } else {
+              state.map[state.key] = object;
+              state.readCount++;
+              if (state.readCount === state.size) {
+                stack.pop();
+                object = state.map;
+              } else {
+                state.key = null;
+                state.type = STATE_MAP_KEY;
+                continue DECODE;
+              }
+            }
+          }
+          return object;
+        }
+    };
+    Decoder2.prototype.readHeadByte = function() {
+      if (this.headByte === HEAD_BYTE_REQUIRED) {
+        this.headByte = this.readU8();
+      }
+      return this.headByte;
+    };
+    Decoder2.prototype.complete = function() {
+      this.headByte = HEAD_BYTE_REQUIRED;
+    };
+    Decoder2.prototype.readArraySize = function() {
+      var headByte = this.readHeadByte();
+      switch (headByte) {
+        case 220:
+          return this.readU16();
+        case 221:
+          return this.readU32();
+        default: {
+          if (headByte < 160) {
+            return headByte - 144;
+          } else {
+            throw new DecodeError("Unrecognized array type byte: ".concat(prettyByte(headByte)));
+          }
+        }
+      }
+    };
+    Decoder2.prototype.pushMapState = function(size) {
+      if (size > this.maxMapLength) {
+        throw new DecodeError("Max length exceeded: map length (".concat(size, ") > maxMapLengthLength (").concat(this.maxMapLength, ")"));
+      }
+      this.stack.push({
+        type: STATE_MAP_KEY,
+        size,
+        key: null,
+        readCount: 0,
+        map: {}
+      });
+    };
+    Decoder2.prototype.pushArrayState = function(size) {
+      if (size > this.maxArrayLength) {
+        throw new DecodeError("Max length exceeded: array length (".concat(size, ") > maxArrayLength (").concat(this.maxArrayLength, ")"));
+      }
+      this.stack.push({
+        type: STATE_ARRAY,
+        size,
+        array: new Array(size),
+        position: 0
+      });
+    };
+    Decoder2.prototype.decodeUtf8String = function(byteLength, headerOffset) {
+      var _a;
+      if (byteLength > this.maxStrLength) {
+        throw new 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 {
+        object = utf8Decode(this.bytes, offset, byteLength);
+      }
+      this.pos += headerOffset + byteLength;
+      return object;
+    };
+    Decoder2.prototype.stateIsMapKey = function() {
+      if (this.stack.length > 0) {
+        var state = this.stack[this.stack.length - 1];
+        return state.type === STATE_MAP_KEY;
+      }
+      return false;
+    };
+    Decoder2.prototype.decodeBinary = function(byteLength, headOffset) {
+      if (byteLength > this.maxBinLength) {
+        throw new 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;
+    };
+    Decoder2.prototype.decodeExtension = function(size, headOffset) {
+      if (size > this.maxExtLength) {
+        throw new 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);
+    };
+    Decoder2.prototype.lookU8 = function() {
+      return this.view.getUint8(this.pos);
+    };
+    Decoder2.prototype.lookU16 = function() {
+      return this.view.getUint16(this.pos);
+    };
+    Decoder2.prototype.lookU32 = function() {
+      return this.view.getUint32(this.pos);
+    };
+    Decoder2.prototype.readU8 = function() {
+      var value = this.view.getUint8(this.pos);
+      this.pos++;
+      return value;
+    };
+    Decoder2.prototype.readI8 = function() {
+      var value = this.view.getInt8(this.pos);
+      this.pos++;
+      return value;
+    };
+    Decoder2.prototype.readU16 = function() {
+      var value = this.view.getUint16(this.pos);
+      this.pos += 2;
+      return value;
+    };
+    Decoder2.prototype.readI16 = function() {
+      var value = this.view.getInt16(this.pos);
+      this.pos += 2;
+      return value;
+    };
+    Decoder2.prototype.readU32 = function() {
+      var value = this.view.getUint32(this.pos);
+      this.pos += 4;
+      return value;
+    };
+    Decoder2.prototype.readI32 = function() {
+      var value = this.view.getInt32(this.pos);
+      this.pos += 4;
+      return value;
+    };
+    Decoder2.prototype.readU64 = function() {
+      var value = getUint64(this.view, this.pos);
+      this.pos += 8;
+      return value;
+    };
+    Decoder2.prototype.readI64 = function() {
+      var value = getInt64(this.view, this.pos);
+      this.pos += 8;
+      return value;
+    };
+    Decoder2.prototype.readU64AsBigInt = function() {
+      var value = this.view.getBigUint64(this.pos);
+      this.pos += 8;
+      return value;
+    };
+    Decoder2.prototype.readI64AsBigInt = function() {
+      var value = this.view.getBigInt64(this.pos);
+      this.pos += 8;
+      return value;
+    };
+    Decoder2.prototype.readF32 = function() {
+      var value = this.view.getFloat32(this.pos);
+      this.pos += 4;
+      return value;
+    };
+    Decoder2.prototype.readF64 = function() {
+      var value = this.view.getFloat64(this.pos);
+      this.pos += 8;
+      return value;
+    };
+    return Decoder2;
+  }()
+);
+
+// node_modules/@msgpack/msgpack/dist.es5+esm/decode.mjs
+function decode(buffer, options) {
+  var decoder = new Decoder(options);
+  return decoder.decode(buffer);
+}
+export {
+  decode,
+  encode
+};