@azure/web-pubsub-chat-client 1.0.0-beta.1

package/dist/browser/index.js

@@ -0,0 +1,4754 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// node_modules/@jspm/core/nodelibs/browser/chunk-DtuTasat.js
+var exports$2 = {};
+var _dewExec$2 = false;
+function dew$2() {
+  if (_dewExec$2) return exports$2;
+  _dewExec$2 = true;
+  exports$2.byteLength = byteLength;
+  exports$2.toByteArray = toByteArray;
+  exports$2.fromByteArray = fromByteArray;
+  var lookup = [];
+  var revLookup = [];
+  var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+  var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  for (var i = 0, len = code.length; i < len; ++i) {
+    lookup[i] = code[i];
+    revLookup[code.charCodeAt(i)] = i;
+  }
+  revLookup["-".charCodeAt(0)] = 62;
+  revLookup["_".charCodeAt(0)] = 63;
+  function getLens(b64) {
+    var len2 = b64.length;
+    if (len2 % 4 > 0) {
+      throw new Error("Invalid string. Length must be a multiple of 4");
+    }
+    var validLen = b64.indexOf("=");
+    if (validLen === -1) validLen = len2;
+    var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+    return [validLen, placeHoldersLen];
+  }
+  function byteLength(b64) {
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+  }
+  function _byteLength(b64, validLen, placeHoldersLen) {
+    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+  }
+  function toByteArray(b64) {
+    var tmp;
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+    var curByte = 0;
+    var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+    var i2;
+    for (i2 = 0; i2 < len2; i2 += 4) {
+      tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+      arr[curByte++] = tmp >> 16 & 255;
+      arr[curByte++] = tmp >> 8 & 255;
+      arr[curByte++] = tmp & 255;
+    }
+    if (placeHoldersLen === 2) {
+      tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+      arr[curByte++] = tmp & 255;
+    }
+    if (placeHoldersLen === 1) {
+      tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+      arr[curByte++] = tmp >> 8 & 255;
+      arr[curByte++] = tmp & 255;
+    }
+    return arr;
+  }
+  function tripletToBase64(num) {
+    return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+  }
+  function encodeChunk(uint8, start, end) {
+    var tmp;
+    var output = [];
+    for (var i2 = start; i2 < end; i2 += 3) {
+      tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
+      output.push(tripletToBase64(tmp));
+    }
+    return output.join("");
+  }
+  function fromByteArray(uint8) {
+    var tmp;
+    var len2 = uint8.length;
+    var extraBytes = len2 % 3;
+    var parts = [];
+    var maxChunkLength = 16383;
+    for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
+      parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+    }
+    if (extraBytes === 1) {
+      tmp = uint8[len2 - 1];
+      parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+    } else if (extraBytes === 2) {
+      tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+      parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+    }
+    return parts.join("");
+  }
+  return exports$2;
+}
+var exports$1 = {};
+var _dewExec$1 = false;
+function dew$1() {
+  if (_dewExec$1) return exports$1;
+  _dewExec$1 = true;
+  exports$1.read = function(buffer, offset, isLE, mLen, nBytes) {
+    var e, m;
+    var eLen = nBytes * 8 - mLen - 1;
+    var eMax = (1 << eLen) - 1;
+    var eBias = eMax >> 1;
+    var nBits = -7;
+    var i = isLE ? nBytes - 1 : 0;
+    var d = isLE ? -1 : 1;
+    var s = buffer[offset + i];
+    i += d;
+    e = s & (1 << -nBits) - 1;
+    s >>= -nBits;
+    nBits += eLen;
+    for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
+    }
+    m = e & (1 << -nBits) - 1;
+    e >>= -nBits;
+    nBits += mLen;
+    for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
+    }
+    if (e === 0) {
+      e = 1 - eBias;
+    } else if (e === eMax) {
+      return m ? NaN : (s ? -1 : 1) * Infinity;
+    } else {
+      m = m + Math.pow(2, mLen);
+      e = e - eBias;
+    }
+    return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+  };
+  exports$1.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+    var e, m, c;
+    var eLen = nBytes * 8 - mLen - 1;
+    var eMax = (1 << eLen) - 1;
+    var eBias = eMax >> 1;
+    var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+    var i = isLE ? 0 : nBytes - 1;
+    var d = isLE ? 1 : -1;
+    var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+    value = Math.abs(value);
+    if (isNaN(value) || value === Infinity) {
+      m = isNaN(value) ? 1 : 0;
+      e = eMax;
+    } else {
+      e = Math.floor(Math.log(value) / Math.LN2);
+      if (value * (c = Math.pow(2, -e)) < 1) {
+        e--;
+        c *= 2;
+      }
+      if (e + eBias >= 1) {
+        value += rt / c;
+      } else {
+        value += rt * Math.pow(2, 1 - eBias);
+      }
+      if (value * c >= 2) {
+        e++;
+        c /= 2;
+      }
+      if (e + eBias >= eMax) {
+        m = 0;
+        e = eMax;
+      } else if (e + eBias >= 1) {
+        m = (value * c - 1) * Math.pow(2, mLen);
+        e = e + eBias;
+      } else {
+        m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+        e = 0;
+      }
+    }
+    for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+    }
+    e = e << mLen | m;
+    eLen += mLen;
+    for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+    }
+    buffer[offset + i - d] |= s * 128;
+  };
+  return exports$1;
+}
+var exports = {};
+var _dewExec = false;
+function dew() {
+  if (_dewExec) return exports;
+  _dewExec = true;
+  const base64 = dew$2();
+  const ieee754 = dew$1();
+  const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+  exports.Buffer = Buffer3;
+  exports.SlowBuffer = SlowBuffer;
+  exports.INSPECT_MAX_BYTES = 50;
+  const K_MAX_LENGTH = 2147483647;
+  exports.kMaxLength = K_MAX_LENGTH;
+  Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport();
+  if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+    console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
+  }
+  function typedArraySupport() {
+    try {
+      const arr = new Uint8Array(1);
+      const proto = {
+        foo: function() {
+          return 42;
+        }
+      };
+      Object.setPrototypeOf(proto, Uint8Array.prototype);
+      Object.setPrototypeOf(arr, proto);
+      return arr.foo() === 42;
+    } catch (e) {
+      return false;
+    }
+  }
+  Object.defineProperty(Buffer3.prototype, "parent", {
+    enumerable: true,
+    get: function() {
+      if (!Buffer3.isBuffer(this)) return void 0;
+      return this.buffer;
+    }
+  });
+  Object.defineProperty(Buffer3.prototype, "offset", {
+    enumerable: true,
+    get: function() {
+      if (!Buffer3.isBuffer(this)) return void 0;
+      return this.byteOffset;
+    }
+  });
+  function createBuffer(length) {
+    if (length > K_MAX_LENGTH) {
+      throw new RangeError('The value "' + length + '" is invalid for option "size"');
+    }
+    const buf = new Uint8Array(length);
+    Object.setPrototypeOf(buf, Buffer3.prototype);
+    return buf;
+  }
+  function Buffer3(arg, encodingOrOffset, length) {
+    if (typeof arg === "number") {
+      if (typeof encodingOrOffset === "string") {
+        throw new TypeError('The "string" argument must be of type string. Received type number');
+      }
+      return allocUnsafe(arg);
+    }
+    return from(arg, encodingOrOffset, length);
+  }
+  Buffer3.poolSize = 8192;
+  function from(value, encodingOrOffset, length) {
+    if (typeof value === "string") {
+      return fromString(value, encodingOrOffset);
+    }
+    if (ArrayBuffer.isView(value)) {
+      return fromArrayView(value);
+    }
+    if (value == null) {
+      throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+    }
+    if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+      return fromArrayBuffer(value, encodingOrOffset, length);
+    }
+    if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+      return fromArrayBuffer(value, encodingOrOffset, length);
+    }
+    if (typeof value === "number") {
+      throw new TypeError('The "value" argument must not be of type number. Received type number');
+    }
+    const valueOf = value.valueOf && value.valueOf();
+    if (valueOf != null && valueOf !== value) {
+      return Buffer3.from(valueOf, encodingOrOffset, length);
+    }
+    const b = fromObject(value);
+    if (b) return b;
+    if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+      return Buffer3.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+    }
+    throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+  }
+  Buffer3.from = function(value, encodingOrOffset, length) {
+    return from(value, encodingOrOffset, length);
+  };
+  Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
+  Object.setPrototypeOf(Buffer3, Uint8Array);
+  function assertSize(size) {
+    if (typeof size !== "number") {
+      throw new TypeError('"size" argument must be of type number');
+    } else if (size < 0) {
+      throw new RangeError('The value "' + size + '" is invalid for option "size"');
+    }
+  }
+  function alloc(size, fill, encoding) {
+    assertSize(size);
+    if (size <= 0) {
+      return createBuffer(size);
+    }
+    if (fill !== void 0) {
+      return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+    }
+    return createBuffer(size);
+  }
+  Buffer3.alloc = function(size, fill, encoding) {
+    return alloc(size, fill, encoding);
+  };
+  function allocUnsafe(size) {
+    assertSize(size);
+    return createBuffer(size < 0 ? 0 : checked(size) | 0);
+  }
+  Buffer3.allocUnsafe = function(size) {
+    return allocUnsafe(size);
+  };
+  Buffer3.allocUnsafeSlow = function(size) {
+    return allocUnsafe(size);
+  };
+  function fromString(string, encoding) {
+    if (typeof encoding !== "string" || encoding === "") {
+      encoding = "utf8";
+    }
+    if (!Buffer3.isEncoding(encoding)) {
+      throw new TypeError("Unknown encoding: " + encoding);
+    }
+    const length = byteLength(string, encoding) | 0;
+    let buf = createBuffer(length);
+    const actual = buf.write(string, encoding);
+    if (actual !== length) {
+      buf = buf.slice(0, actual);
+    }
+    return buf;
+  }
+  function fromArrayLike(array) {
+    const length = array.length < 0 ? 0 : checked(array.length) | 0;
+    const buf = createBuffer(length);
+    for (let i = 0; i < length; i += 1) {
+      buf[i] = array[i] & 255;
+    }
+    return buf;
+  }
+  function fromArrayView(arrayView) {
+    if (isInstance(arrayView, Uint8Array)) {
+      const copy = new Uint8Array(arrayView);
+      return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+    }
+    return fromArrayLike(arrayView);
+  }
+  function fromArrayBuffer(array, byteOffset, length) {
+    if (byteOffset < 0 || array.byteLength < byteOffset) {
+      throw new RangeError('"offset" is outside of buffer bounds');
+    }
+    if (array.byteLength < byteOffset + (length || 0)) {
+      throw new RangeError('"length" is outside of buffer bounds');
+    }
+    let buf;
+    if (byteOffset === void 0 && length === void 0) {
+      buf = new Uint8Array(array);
+    } else if (length === void 0) {
+      buf = new Uint8Array(array, byteOffset);
+    } else {
+      buf = new Uint8Array(array, byteOffset, length);
+    }
+    Object.setPrototypeOf(buf, Buffer3.prototype);
+    return buf;
+  }
+  function fromObject(obj) {
+    if (Buffer3.isBuffer(obj)) {
+      const len = checked(obj.length) | 0;
+      const buf = createBuffer(len);
+      if (buf.length === 0) {
+        return buf;
+      }
+      obj.copy(buf, 0, 0, len);
+      return buf;
+    }
+    if (obj.length !== void 0) {
+      if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+        return createBuffer(0);
+      }
+      return fromArrayLike(obj);
+    }
+    if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+      return fromArrayLike(obj.data);
+    }
+  }
+  function checked(length) {
+    if (length >= K_MAX_LENGTH) {
+      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+    }
+    return length | 0;
+  }
+  function SlowBuffer(length) {
+    if (+length != length) {
+      length = 0;
+    }
+    return Buffer3.alloc(+length);
+  }
+  Buffer3.isBuffer = function isBuffer(b) {
+    return b != null && b._isBuffer === true && b !== Buffer3.prototype;
+  };
+  Buffer3.compare = function compare(a, b) {
+    if (isInstance(a, Uint8Array)) a = Buffer3.from(a, a.offset, a.byteLength);
+    if (isInstance(b, Uint8Array)) b = Buffer3.from(b, b.offset, b.byteLength);
+    if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) {
+      throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+    }
+    if (a === b) return 0;
+    let x = a.length;
+    let y = b.length;
+    for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+      if (a[i] !== b[i]) {
+        x = a[i];
+        y = b[i];
+        break;
+      }
+    }
+    if (x < y) return -1;
+    if (y < x) return 1;
+    return 0;
+  };
+  Buffer3.isEncoding = function isEncoding(encoding) {
+    switch (String(encoding).toLowerCase()) {
+      case "hex":
+      case "utf8":
+      case "utf-8":
+      case "ascii":
+      case "latin1":
+      case "binary":
+      case "base64":
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return true;
+      default:
+        return false;
+    }
+  };
+  Buffer3.concat = function concat(list, length) {
+    if (!Array.isArray(list)) {
+      throw new TypeError('"list" argument must be an Array of Buffers');
+    }
+    if (list.length === 0) {
+      return Buffer3.alloc(0);
+    }
+    let i;
+    if (length === void 0) {
+      length = 0;
+      for (i = 0; i < list.length; ++i) {
+        length += list[i].length;
+      }
+    }
+    const buffer = Buffer3.allocUnsafe(length);
+    let pos = 0;
+    for (i = 0; i < list.length; ++i) {
+      let buf = list[i];
+      if (isInstance(buf, Uint8Array)) {
+        if (pos + buf.length > buffer.length) {
+          if (!Buffer3.isBuffer(buf)) buf = Buffer3.from(buf);
+          buf.copy(buffer, pos);
+        } else {
+          Uint8Array.prototype.set.call(buffer, buf, pos);
+        }
+      } else if (!Buffer3.isBuffer(buf)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      } else {
+        buf.copy(buffer, pos);
+      }
+      pos += buf.length;
+    }
+    return buffer;
+  };
+  function byteLength(string, encoding) {
+    if (Buffer3.isBuffer(string)) {
+      return string.length;
+    }
+    if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+      return string.byteLength;
+    }
+    if (typeof string !== "string") {
+      throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
+    }
+    const len = string.length;
+    const mustMatch = arguments.length > 2 && arguments[2] === true;
+    if (!mustMatch && len === 0) return 0;
+    let loweredCase = false;
+    for (; ; ) {
+      switch (encoding) {
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return len;
+        case "utf8":
+        case "utf-8":
+          return utf8ToBytes(string).length;
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return len * 2;
+        case "hex":
+          return len >>> 1;
+        case "base64":
+          return base64ToBytes(string).length;
+        default:
+          if (loweredCase) {
+            return mustMatch ? -1 : utf8ToBytes(string).length;
+          }
+          encoding = ("" + encoding).toLowerCase();
+          loweredCase = true;
+      }
+    }
+  }
+  Buffer3.byteLength = byteLength;
+  function slowToString(encoding, start, end) {
+    let loweredCase = false;
+    if (start === void 0 || start < 0) {
+      start = 0;
+    }
+    if (start > this.length) {
+      return "";
+    }
+    if (end === void 0 || end > this.length) {
+      end = this.length;
+    }
+    if (end <= 0) {
+      return "";
+    }
+    end >>>= 0;
+    start >>>= 0;
+    if (end <= start) {
+      return "";
+    }
+    if (!encoding) encoding = "utf8";
+    while (true) {
+      switch (encoding) {
+        case "hex":
+          return hexSlice(this, start, end);
+        case "utf8":
+        case "utf-8":
+          return utf8Slice(this, start, end);
+        case "ascii":
+          return asciiSlice(this, start, end);
+        case "latin1":
+        case "binary":
+          return latin1Slice(this, start, end);
+        case "base64":
+          return base64Slice(this, start, end);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return utf16leSlice(this, start, end);
+        default:
+          if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+          encoding = (encoding + "").toLowerCase();
+          loweredCase = true;
+      }
+    }
+  }
+  Buffer3.prototype._isBuffer = true;
+  function swap(b, n, m) {
+    const i = b[n];
+    b[n] = b[m];
+    b[m] = i;
+  }
+  Buffer3.prototype.swap16 = function swap16() {
+    const len = this.length;
+    if (len % 2 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 16-bits");
+    }
+    for (let i = 0; i < len; i += 2) {
+      swap(this, i, i + 1);
+    }
+    return this;
+  };
+  Buffer3.prototype.swap32 = function swap32() {
+    const len = this.length;
+    if (len % 4 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 32-bits");
+    }
+    for (let i = 0; i < len; i += 4) {
+      swap(this, i, i + 3);
+      swap(this, i + 1, i + 2);
+    }
+    return this;
+  };
+  Buffer3.prototype.swap64 = function swap64() {
+    const len = this.length;
+    if (len % 8 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 64-bits");
+    }
+    for (let i = 0; i < len; i += 8) {
+      swap(this, i, i + 7);
+      swap(this, i + 1, i + 6);
+      swap(this, i + 2, i + 5);
+      swap(this, i + 3, i + 4);
+    }
+    return this;
+  };
+  Buffer3.prototype.toString = function toString() {
+    const length = this.length;
+    if (length === 0) return "";
+    if (arguments.length === 0) return utf8Slice(this, 0, length);
+    return slowToString.apply(this, arguments);
+  };
+  Buffer3.prototype.toLocaleString = Buffer3.prototype.toString;
+  Buffer3.prototype.equals = function equals(b) {
+    if (!Buffer3.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
+    if (this === b) return true;
+    return Buffer3.compare(this, b) === 0;
+  };
+  Buffer3.prototype.inspect = function inspect() {
+    let str = "";
+    const max = exports.INSPECT_MAX_BYTES;
+    str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+    if (this.length > max) str += " ... ";
+    return "<Buffer " + str + ">";
+  };
+  if (customInspectSymbol) {
+    Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
+  }
+  Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+    if (isInstance(target, Uint8Array)) {
+      target = Buffer3.from(target, target.offset, target.byteLength);
+    }
+    if (!Buffer3.isBuffer(target)) {
+      throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
+    }
+    if (start === void 0) {
+      start = 0;
+    }
+    if (end === void 0) {
+      end = target ? target.length : 0;
+    }
+    if (thisStart === void 0) {
+      thisStart = 0;
+    }
+    if (thisEnd === void 0) {
+      thisEnd = this.length;
+    }
+    if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+      throw new RangeError("out of range index");
+    }
+    if (thisStart >= thisEnd && start >= end) {
+      return 0;
+    }
+    if (thisStart >= thisEnd) {
+      return -1;
+    }
+    if (start >= end) {
+      return 1;
+    }
+    start >>>= 0;
+    end >>>= 0;
+    thisStart >>>= 0;
+    thisEnd >>>= 0;
+    if (this === target) return 0;
+    let x = thisEnd - thisStart;
+    let y = end - start;
+    const len = Math.min(x, y);
+    const thisCopy = this.slice(thisStart, thisEnd);
+    const targetCopy = target.slice(start, end);
+    for (let i = 0; i < len; ++i) {
+      if (thisCopy[i] !== targetCopy[i]) {
+        x = thisCopy[i];
+        y = targetCopy[i];
+        break;
+      }
+    }
+    if (x < y) return -1;
+    if (y < x) return 1;
+    return 0;
+  };
+  function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+    if (buffer.length === 0) return -1;
+    if (typeof byteOffset === "string") {
+      encoding = byteOffset;
+      byteOffset = 0;
+    } else if (byteOffset > 2147483647) {
+      byteOffset = 2147483647;
+    } else if (byteOffset < -2147483648) {
+      byteOffset = -2147483648;
+    }
+    byteOffset = +byteOffset;
+    if (numberIsNaN(byteOffset)) {
+      byteOffset = dir ? 0 : buffer.length - 1;
+    }
+    if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+    if (byteOffset >= buffer.length) {
+      if (dir) return -1;
+      else byteOffset = buffer.length - 1;
+    } else if (byteOffset < 0) {
+      if (dir) byteOffset = 0;
+      else return -1;
+    }
+    if (typeof val === "string") {
+      val = Buffer3.from(val, encoding);
+    }
+    if (Buffer3.isBuffer(val)) {
+      if (val.length === 0) {
+        return -1;
+      }
+      return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+    } else if (typeof val === "number") {
+      val = val & 255;
+      if (typeof Uint8Array.prototype.indexOf === "function") {
+        if (dir) {
+          return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+        } else {
+          return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+        }
+      }
+      return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+    }
+    throw new TypeError("val must be string, number or Buffer");
+  }
+  function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+    let indexSize = 1;
+    let arrLength = arr.length;
+    let valLength = val.length;
+    if (encoding !== void 0) {
+      encoding = String(encoding).toLowerCase();
+      if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+        if (arr.length < 2 || val.length < 2) {
+          return -1;
+        }
+        indexSize = 2;
+        arrLength /= 2;
+        valLength /= 2;
+        byteOffset /= 2;
+      }
+    }
+    function read(buf, i2) {
+      if (indexSize === 1) {
+        return buf[i2];
+      } else {
+        return buf.readUInt16BE(i2 * indexSize);
+      }
+    }
+    let i;
+    if (dir) {
+      let foundIndex = -1;
+      for (i = byteOffset; i < arrLength; i++) {
+        if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+          if (foundIndex === -1) foundIndex = i;
+          if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
+        } else {
+          if (foundIndex !== -1) i -= i - foundIndex;
+          foundIndex = -1;
+        }
+      }
+    } else {
+      if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
+      for (i = byteOffset; i >= 0; i--) {
+        let found = true;
+        for (let j = 0; j < valLength; j++) {
+          if (read(arr, i + j) !== read(val, j)) {
+            found = false;
+            break;
+          }
+        }
+        if (found) return i;
+      }
+    }
+    return -1;
+  }
+  Buffer3.prototype.includes = function includes(val, byteOffset, encoding) {
+    return this.indexOf(val, byteOffset, encoding) !== -1;
+  };
+  Buffer3.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+    return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+  };
+  Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+    return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+  };
+  function hexWrite(buf, string, offset, length) {
+    offset = Number(offset) || 0;
+    const remaining = buf.length - offset;
+    if (!length) {
+      length = remaining;
+    } else {
+      length = Number(length);
+      if (length > remaining) {
+        length = remaining;
+      }
+    }
+    const strLen = string.length;
+    if (length > strLen / 2) {
+      length = strLen / 2;
+    }
+    let i;
+    for (i = 0; i < length; ++i) {
+      const parsed = parseInt(string.substr(i * 2, 2), 16);
+      if (numberIsNaN(parsed)) return i;
+      buf[offset + i] = parsed;
+    }
+    return i;
+  }
+  function utf8Write(buf, string, offset, length) {
+    return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+  }
+  function asciiWrite(buf, string, offset, length) {
+    return blitBuffer(asciiToBytes(string), buf, offset, length);
+  }
+  function base64Write(buf, string, offset, length) {
+    return blitBuffer(base64ToBytes(string), buf, offset, length);
+  }
+  function ucs2Write(buf, string, offset, length) {
+    return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+  }
+  Buffer3.prototype.write = function write(string, offset, length, encoding) {
+    if (offset === void 0) {
+      encoding = "utf8";
+      length = this.length;
+      offset = 0;
+    } else if (length === void 0 && typeof offset === "string") {
+      encoding = offset;
+      length = this.length;
+      offset = 0;
+    } else if (isFinite(offset)) {
+      offset = offset >>> 0;
+      if (isFinite(length)) {
+        length = length >>> 0;
+        if (encoding === void 0) encoding = "utf8";
+      } else {
+        encoding = length;
+        length = void 0;
+      }
+    } else {
+      throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+    }
+    const remaining = this.length - offset;
+    if (length === void 0 || length > remaining) length = remaining;
+    if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
+      throw new RangeError("Attempt to write outside buffer bounds");
+    }
+    if (!encoding) encoding = "utf8";
+    let loweredCase = false;
+    for (; ; ) {
+      switch (encoding) {
+        case "hex":
+          return hexWrite(this, string, offset, length);
+        case "utf8":
+        case "utf-8":
+          return utf8Write(this, string, offset, length);
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return asciiWrite(this, string, offset, length);
+        case "base64":
+          return base64Write(this, string, offset, length);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return ucs2Write(this, string, offset, length);
+        default:
+          if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+          encoding = ("" + encoding).toLowerCase();
+          loweredCase = true;
+      }
+    }
+  };
+  Buffer3.prototype.toJSON = function toJSON() {
+    return {
+      type: "Buffer",
+      data: Array.prototype.slice.call(this._arr || this, 0)
+    };
+  };
+  function base64Slice(buf, start, end) {
+    if (start === 0 && end === buf.length) {
+      return base64.fromByteArray(buf);
+    } else {
+      return base64.fromByteArray(buf.slice(start, end));
+    }
+  }
+  function utf8Slice(buf, start, end) {
+    end = Math.min(buf.length, end);
+    const res = [];
+    let i = start;
+    while (i < end) {
+      const firstByte = buf[i];
+      let codePoint = null;
+      let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+      if (i + bytesPerSequence <= end) {
+        let secondByte, thirdByte, fourthByte, tempCodePoint;
+        switch (bytesPerSequence) {
+          case 1:
+            if (firstByte < 128) {
+              codePoint = firstByte;
+            }
+            break;
+          case 2:
+            secondByte = buf[i + 1];
+            if ((secondByte & 192) === 128) {
+              tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+              if (tempCodePoint > 127) {
+                codePoint = tempCodePoint;
+              }
+            }
+            break;
+          case 3:
+            secondByte = buf[i + 1];
+            thirdByte = buf[i + 2];
+            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+              tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+              if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                codePoint = tempCodePoint;
+              }
+            }
+            break;
+          case 4:
+            secondByte = buf[i + 1];
+            thirdByte = buf[i + 2];
+            fourthByte = buf[i + 3];
+            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+              tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+              if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                codePoint = tempCodePoint;
+              }
+            }
+        }
+      }
+      if (codePoint === null) {
+        codePoint = 65533;
+        bytesPerSequence = 1;
+      } else if (codePoint > 65535) {
+        codePoint -= 65536;
+        res.push(codePoint >>> 10 & 1023 | 55296);
+        codePoint = 56320 | codePoint & 1023;
+      }
+      res.push(codePoint);
+      i += bytesPerSequence;
+    }
+    return decodeCodePointsArray(res);
+  }
+  const MAX_ARGUMENTS_LENGTH = 4096;
+  function decodeCodePointsArray(codePoints) {
+    const len = codePoints.length;
+    if (len <= MAX_ARGUMENTS_LENGTH) {
+      return String.fromCharCode.apply(String, codePoints);
+    }
+    let res = "";
+    let i = 0;
+    while (i < len) {
+      res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
+    }
+    return res;
+  }
+  function asciiSlice(buf, start, end) {
+    let ret = "";
+    end = Math.min(buf.length, end);
+    for (let i = start; i < end; ++i) {
+      ret += String.fromCharCode(buf[i] & 127);
+    }
+    return ret;
+  }
+  function latin1Slice(buf, start, end) {
+    let ret = "";
+    end = Math.min(buf.length, end);
+    for (let i = start; i < end; ++i) {
+      ret += String.fromCharCode(buf[i]);
+    }
+    return ret;
+  }
+  function hexSlice(buf, start, end) {
+    const len = buf.length;
+    if (!start || start < 0) start = 0;
+    if (!end || end < 0 || end > len) end = len;
+    let out = "";
+    for (let i = start; i < end; ++i) {
+      out += hexSliceLookupTable[buf[i]];
+    }
+    return out;
+  }
+  function utf16leSlice(buf, start, end) {
+    const bytes = buf.slice(start, end);
+    let res = "";
+    for (let i = 0; i < bytes.length - 1; i += 2) {
+      res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+    }
+    return res;
+  }
+  Buffer3.prototype.slice = function slice(start, end) {
+    const len = this.length;
+    start = ~~start;
+    end = end === void 0 ? len : ~~end;
+    if (start < 0) {
+      start += len;
+      if (start < 0) start = 0;
+    } else if (start > len) {
+      start = len;
+    }
+    if (end < 0) {
+      end += len;
+      if (end < 0) end = 0;
+    } else if (end > len) {
+      end = len;
+    }
+    if (end < start) end = start;
+    const newBuf = this.subarray(start, end);
+    Object.setPrototypeOf(newBuf, Buffer3.prototype);
+    return newBuf;
+  };
+  function checkOffset(offset, ext, length) {
+    if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
+    if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
+  }
+  Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+    offset = offset >>> 0;
+    byteLength2 = byteLength2 >>> 0;
+    if (!noAssert) checkOffset(offset, byteLength2, this.length);
+    let val = this[offset];
+    let mul = 1;
+    let i = 0;
+    while (++i < byteLength2 && (mul *= 256)) {
+      val += this[offset + i] * mul;
+    }
+    return val;
+  };
+  Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+    offset = offset >>> 0;
+    byteLength2 = byteLength2 >>> 0;
+    if (!noAssert) {
+      checkOffset(offset, byteLength2, this.length);
+    }
+    let val = this[offset + --byteLength2];
+    let mul = 1;
+    while (byteLength2 > 0 && (mul *= 256)) {
+      val += this[offset + --byteLength2] * mul;
+    }
+    return val;
+  };
+  Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 1, this.length);
+    return this[offset];
+  };
+  Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 2, this.length);
+    return this[offset] | this[offset + 1] << 8;
+  };
+  Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 2, this.length);
+    return this[offset] << 8 | this[offset + 1];
+  };
+  Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 4, this.length);
+    return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+  };
+  Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 4, this.length);
+    return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+  };
+  Buffer3.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+    offset = offset >>> 0;
+    validateNumber(offset, "offset");
+    const first = this[offset];
+    const last = this[offset + 7];
+    if (first === void 0 || last === void 0) {
+      boundsError(offset, this.length - 8);
+    }
+    const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
+    const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
+    return BigInt(lo) + (BigInt(hi) << BigInt(32));
+  });
+  Buffer3.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+    offset = offset >>> 0;
+    validateNumber(offset, "offset");
+    const first = this[offset];
+    const last = this[offset + 7];
+    if (first === void 0 || last === void 0) {
+      boundsError(offset, this.length - 8);
+    }
+    const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+    const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
+    return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+  });
+  Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+    offset = offset >>> 0;
+    byteLength2 = byteLength2 >>> 0;
+    if (!noAssert) checkOffset(offset, byteLength2, this.length);
+    let val = this[offset];
+    let mul = 1;
+    let i = 0;
+    while (++i < byteLength2 && (mul *= 256)) {
+      val += this[offset + i] * mul;
+    }
+    mul *= 128;
+    if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+    return val;
+  };
+  Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+    offset = offset >>> 0;
+    byteLength2 = byteLength2 >>> 0;
+    if (!noAssert) checkOffset(offset, byteLength2, this.length);
+    let i = byteLength2;
+    let mul = 1;
+    let val = this[offset + --i];
+    while (i > 0 && (mul *= 256)) {
+      val += this[offset + --i] * mul;
+    }
+    mul *= 128;
+    if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+    return val;
+  };
+  Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 1, this.length);
+    if (!(this[offset] & 128)) return this[offset];
+    return (255 - this[offset] + 1) * -1;
+  };
+  Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 2, this.length);
+    const val = this[offset] | this[offset + 1] << 8;
+    return val & 32768 ? val | 4294901760 : val;
+  };
+  Buffer3.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 2, this.length);
+    const val = this[offset + 1] | this[offset] << 8;
+    return val & 32768 ? val | 4294901760 : val;
+  };
+  Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 4, this.length);
+    return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+  };
+  Buffer3.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 4, this.length);
+    return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+  };
+  Buffer3.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+    offset = offset >>> 0;
+    validateNumber(offset, "offset");
+    const first = this[offset];
+    const last = this[offset + 7];
+    if (first === void 0 || last === void 0) {
+      boundsError(offset, this.length - 8);
+    }
+    const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
+    return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
+  });
+  Buffer3.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+    offset = offset >>> 0;
+    validateNumber(offset, "offset");
+    const first = this[offset];
+    const last = this[offset + 7];
+    if (first === void 0 || last === void 0) {
+      boundsError(offset, this.length - 8);
+    }
+    const val = (first << 24) + // Overflow
+    this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+    return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
+  });
+  Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 4, this.length);
+    return ieee754.read(this, offset, true, 23, 4);
+  };
+  Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 4, this.length);
+    return ieee754.read(this, offset, false, 23, 4);
+  };
+  Buffer3.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 8, this.length);
+    return ieee754.read(this, offset, true, 52, 8);
+  };
+  Buffer3.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+    offset = offset >>> 0;
+    if (!noAssert) checkOffset(offset, 8, this.length);
+    return ieee754.read(this, offset, false, 52, 8);
+  };
+  function checkInt(buf, value, offset, ext, max, min) {
+    if (!Buffer3.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
+    if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
+    if (offset + ext > buf.length) throw new RangeError("Index out of range");
+  }
+  Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    byteLength2 = byteLength2 >>> 0;
+    if (!noAssert) {
+      const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+      checkInt(this, value, offset, byteLength2, maxBytes, 0);
+    }
+    let mul = 1;
+    let i = 0;
+    this[offset] = value & 255;
+    while (++i < byteLength2 && (mul *= 256)) {
+      this[offset + i] = value / mul & 255;
+    }
+    return offset + byteLength2;
+  };
+  Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    byteLength2 = byteLength2 >>> 0;
+    if (!noAssert) {
+      const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+      checkInt(this, value, offset, byteLength2, maxBytes, 0);
+    }
+    let i = byteLength2 - 1;
+    let mul = 1;
+    this[offset + i] = value & 255;
+    while (--i >= 0 && (mul *= 256)) {
+      this[offset + i] = value / mul & 255;
+    }
+    return offset + byteLength2;
+  };
+  Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
+    this[offset] = value & 255;
+    return offset + 1;
+  };
+  Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8;
+    return offset + 2;
+  };
+  Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+    this[offset] = value >>> 8;
+    this[offset + 1] = value & 255;
+    return offset + 2;
+  };
+  Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+    this[offset + 3] = value >>> 24;
+    this[offset + 2] = value >>> 16;
+    this[offset + 1] = value >>> 8;
+    this[offset] = value & 255;
+    return offset + 4;
+  };
+  Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+    this[offset] = value >>> 24;
+    this[offset + 1] = value >>> 16;
+    this[offset + 2] = value >>> 8;
+    this[offset + 3] = value & 255;
+    return offset + 4;
+  };
+  function wrtBigUInt64LE(buf, value, offset, min, max) {
+    checkIntBI(value, min, max, buf, offset, 7);
+    let lo = Number(value & BigInt(4294967295));
+    buf[offset++] = lo;
+    lo = lo >> 8;
+    buf[offset++] = lo;
+    lo = lo >> 8;
+    buf[offset++] = lo;
+    lo = lo >> 8;
+    buf[offset++] = lo;
+    let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+    buf[offset++] = hi;
+    hi = hi >> 8;
+    buf[offset++] = hi;
+    hi = hi >> 8;
+    buf[offset++] = hi;
+    hi = hi >> 8;
+    buf[offset++] = hi;
+    return offset;
+  }
+  function wrtBigUInt64BE(buf, value, offset, min, max) {
+    checkIntBI(value, min, max, buf, offset, 7);
+    let lo = Number(value & BigInt(4294967295));
+    buf[offset + 7] = lo;
+    lo = lo >> 8;
+    buf[offset + 6] = lo;
+    lo = lo >> 8;
+    buf[offset + 5] = lo;
+    lo = lo >> 8;
+    buf[offset + 4] = lo;
+    let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+    buf[offset + 3] = hi;
+    hi = hi >> 8;
+    buf[offset + 2] = hi;
+    hi = hi >> 8;
+    buf[offset + 1] = hi;
+    hi = hi >> 8;
+    buf[offset] = hi;
+    return offset + 8;
+  }
+  Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+    return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+  });
+  Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+    return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+  });
+  Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      const limit = Math.pow(2, 8 * byteLength2 - 1);
+      checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+    }
+    let i = 0;
+    let mul = 1;
+    let sub = 0;
+    this[offset] = value & 255;
+    while (++i < byteLength2 && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+        sub = 1;
+      }
+      this[offset + i] = (value / mul >> 0) - sub & 255;
+    }
+    return offset + byteLength2;
+  };
+  Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      const limit = Math.pow(2, 8 * byteLength2 - 1);
+      checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+    }
+    let i = byteLength2 - 1;
+    let mul = 1;
+    let sub = 0;
+    this[offset + i] = value & 255;
+    while (--i >= 0 && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+        sub = 1;
+      }
+      this[offset + i] = (value / mul >> 0) - sub & 255;
+    }
+    return offset + byteLength2;
+  };
+  Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
+    if (value < 0) value = 255 + value + 1;
+    this[offset] = value & 255;
+    return offset + 1;
+  };
+  Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8;
+    return offset + 2;
+  };
+  Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+    this[offset] = value >>> 8;
+    this[offset + 1] = value & 255;
+    return offset + 2;
+  };
+  Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+    this[offset] = value & 255;
+    this[offset + 1] = value >>> 8;
+    this[offset + 2] = value >>> 16;
+    this[offset + 3] = value >>> 24;
+    return offset + 4;
+  };
+  Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+    if (value < 0) value = 4294967295 + value + 1;
+    this[offset] = value >>> 24;
+    this[offset + 1] = value >>> 16;
+    this[offset + 2] = value >>> 8;
+    this[offset + 3] = value & 255;
+    return offset + 4;
+  };
+  Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+    return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  });
+  Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
+    return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  });
+  function checkIEEE754(buf, value, offset, ext, max, min) {
+    if (offset + ext > buf.length) throw new RangeError("Index out of range");
+    if (offset < 0) throw new RangeError("Index out of range");
+  }
+  function writeFloat(buf, value, offset, littleEndian, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      checkIEEE754(buf, value, offset, 4);
+    }
+    ieee754.write(buf, value, offset, littleEndian, 23, 4);
+    return offset + 4;
+  }
+  Buffer3.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+    return writeFloat(this, value, offset, true, noAssert);
+  };
+  Buffer3.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+    return writeFloat(this, value, offset, false, noAssert);
+  };
+  function writeDouble(buf, value, offset, littleEndian, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    if (!noAssert) {
+      checkIEEE754(buf, value, offset, 8);
+    }
+    ieee754.write(buf, value, offset, littleEndian, 52, 8);
+    return offset + 8;
+  }
+  Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+    return writeDouble(this, value, offset, true, noAssert);
+  };
+  Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+    return writeDouble(this, value, offset, false, noAssert);
+  };
+  Buffer3.prototype.copy = function copy(target, targetStart, start, end) {
+    if (!Buffer3.isBuffer(target)) throw new TypeError("argument should be a Buffer");
+    if (!start) start = 0;
+    if (!end && end !== 0) end = this.length;
+    if (targetStart >= target.length) targetStart = target.length;
+    if (!targetStart) targetStart = 0;
+    if (end > 0 && end < start) end = start;
+    if (end === start) return 0;
+    if (target.length === 0 || this.length === 0) return 0;
+    if (targetStart < 0) {
+      throw new RangeError("targetStart out of bounds");
+    }
+    if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
+    if (end < 0) throw new RangeError("sourceEnd out of bounds");
+    if (end > this.length) end = this.length;
+    if (target.length - targetStart < end - start) {
+      end = target.length - targetStart + start;
+    }
+    const len = end - start;
+    if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+      this.copyWithin(targetStart, start, end);
+    } else {
+      Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
+    }
+    return len;
+  };
+  Buffer3.prototype.fill = function fill(val, start, end, encoding) {
+    if (typeof val === "string") {
+      if (typeof start === "string") {
+        encoding = start;
+        start = 0;
+        end = this.length;
+      } else if (typeof end === "string") {
+        encoding = end;
+        end = this.length;
+      }
+      if (encoding !== void 0 && typeof encoding !== "string") {
+        throw new TypeError("encoding must be a string");
+      }
+      if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      if (val.length === 1) {
+        const code = val.charCodeAt(0);
+        if (encoding === "utf8" && code < 128 || encoding === "latin1") {
+          val = code;
+        }
+      }
+    } else if (typeof val === "number") {
+      val = val & 255;
+    } else if (typeof val === "boolean") {
+      val = Number(val);
+    }
+    if (start < 0 || this.length < start || this.length < end) {
+      throw new RangeError("Out of range index");
+    }
+    if (end <= start) {
+      return this;
+    }
+    start = start >>> 0;
+    end = end === void 0 ? this.length : end >>> 0;
+    if (!val) val = 0;
+    let i;
+    if (typeof val === "number") {
+      for (i = start; i < end; ++i) {
+        this[i] = val;
+      }
+    } else {
+      const bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
+      const len = bytes.length;
+      if (len === 0) {
+        throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+      }
+      for (i = 0; i < end - start; ++i) {
+        this[i + start] = bytes[i % len];
+      }
+    }
+    return this;
+  };
+  const errors = {};
+  function E(sym, getMessage, Base) {
+    errors[sym] = class NodeError extends Base {
+      constructor() {
+        super();
+        Object.defineProperty(this, "message", {
+          value: getMessage.apply(this, arguments),
+          writable: true,
+          configurable: true
+        });
+        this.name = `${this.name} [${sym}]`;
+        this.stack;
+        delete this.name;
+      }
+      get code() {
+        return sym;
+      }
+      set code(value) {
+        Object.defineProperty(this, "code", {
+          configurable: true,
+          enumerable: true,
+          value,
+          writable: true
+        });
+      }
+      toString() {
+        return `${this.name} [${sym}]: ${this.message}`;
+      }
+    };
+  }
+  E("ERR_BUFFER_OUT_OF_BOUNDS", function(name2) {
+    if (name2) {
+      return `${name2} is outside of buffer bounds`;
+    }
+    return "Attempt to access memory outside buffer bounds";
+  }, RangeError);
+  E("ERR_INVALID_ARG_TYPE", function(name2, actual) {
+    return `The "${name2}" argument must be of type number. Received type ${typeof actual}`;
+  }, TypeError);
+  E("ERR_OUT_OF_RANGE", function(str, range, input) {
+    let msg = `The value of "${str}" is out of range.`;
+    let received = input;
+    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+      received = addNumericalSeparator(String(input));
+    } else if (typeof input === "bigint") {
+      received = String(input);
+      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
+        received = addNumericalSeparator(received);
+      }
+      received += "n";
+    }
+    msg += ` It must be ${range}. Received ${received}`;
+    return msg;
+  }, RangeError);
+  function addNumericalSeparator(val) {
+    let res = "";
+    let i = val.length;
+    const start = val[0] === "-" ? 1 : 0;
+    for (; i >= start + 4; i -= 3) {
+      res = `_${val.slice(i - 3, i)}${res}`;
+    }
+    return `${val.slice(0, i)}${res}`;
+  }
+  function checkBounds(buf, offset, byteLength2) {
+    validateNumber(offset, "offset");
+    if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
+      boundsError(offset, buf.length - (byteLength2 + 1));
+    }
+  }
+  function checkIntBI(value, min, max, buf, offset, byteLength2) {
+    if (value > max || value < min) {
+      const n = typeof min === "bigint" ? "n" : "";
+      let range;
+      {
+        if (min === 0 || min === BigInt(0)) {
+          range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+        } else {
+          range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
+        }
+      }
+      throw new errors.ERR_OUT_OF_RANGE("value", range, value);
+    }
+    checkBounds(buf, offset, byteLength2);
+  }
+  function validateNumber(value, name2) {
+    if (typeof value !== "number") {
+      throw new errors.ERR_INVALID_ARG_TYPE(name2, "number", value);
+    }
+  }
+  function boundsError(value, length, type) {
+    if (Math.floor(value) !== value) {
+      validateNumber(value, type);
+      throw new errors.ERR_OUT_OF_RANGE("offset", "an integer", value);
+    }
+    if (length < 0) {
+      throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+    }
+    throw new errors.ERR_OUT_OF_RANGE("offset", `>= ${0} and <= ${length}`, value);
+  }
+  const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+  function base64clean(str) {
+    str = str.split("=")[0];
+    str = str.trim().replace(INVALID_BASE64_RE, "");
+    if (str.length < 2) return "";
+    while (str.length % 4 !== 0) {
+      str = str + "=";
+    }
+    return str;
+  }
+  function utf8ToBytes(string, units) {
+    units = units || Infinity;
+    let codePoint;
+    const length = string.length;
+    let leadSurrogate = null;
+    const bytes = [];
+    for (let i = 0; i < length; ++i) {
+      codePoint = string.charCodeAt(i);
+      if (codePoint > 55295 && codePoint < 57344) {
+        if (!leadSurrogate) {
+          if (codePoint > 56319) {
+            if ((units -= 3) > -1) bytes.push(239, 191, 189);
+            continue;
+          } else if (i + 1 === length) {
+            if ((units -= 3) > -1) bytes.push(239, 191, 189);
+            continue;
+          }
+          leadSurrogate = codePoint;
+          continue;
+        }
+        if (codePoint < 56320) {
+          if ((units -= 3) > -1) bytes.push(239, 191, 189);
+          leadSurrogate = codePoint;
+          continue;
+        }
+        codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+      } else if (leadSurrogate) {
+        if ((units -= 3) > -1) bytes.push(239, 191, 189);
+      }
+      leadSurrogate = null;
+      if (codePoint < 128) {
+        if ((units -= 1) < 0) break;
+        bytes.push(codePoint);
+      } else if (codePoint < 2048) {
+        if ((units -= 2) < 0) break;
+        bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
+      } else if (codePoint < 65536) {
+        if ((units -= 3) < 0) break;
+        bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+      } else if (codePoint < 1114112) {
+        if ((units -= 4) < 0) break;
+        bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+      } else {
+        throw new Error("Invalid code point");
+      }
+    }
+    return bytes;
+  }
+  function asciiToBytes(str) {
+    const byteArray = [];
+    for (let i = 0; i < str.length; ++i) {
+      byteArray.push(str.charCodeAt(i) & 255);
+    }
+    return byteArray;
+  }
+  function utf16leToBytes(str, units) {
+    let c, hi, lo;
+    const byteArray = [];
+    for (let i = 0; i < str.length; ++i) {
+      if ((units -= 2) < 0) break;
+      c = str.charCodeAt(i);
+      hi = c >> 8;
+      lo = c % 256;
+      byteArray.push(lo);
+      byteArray.push(hi);
+    }
+    return byteArray;
+  }
+  function base64ToBytes(str) {
+    return base64.toByteArray(base64clean(str));
+  }
+  function blitBuffer(src, dst, offset, length) {
+    let i;
+    for (i = 0; i < length; ++i) {
+      if (i + offset >= dst.length || i >= src.length) break;
+      dst[i + offset] = src[i];
+    }
+    return i;
+  }
+  function isInstance(obj, type) {
+    return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+  }
+  function numberIsNaN(obj) {
+    return obj !== obj;
+  }
+  const hexSliceLookupTable = (function() {
+    const alphabet = "0123456789abcdef";
+    const table = new Array(256);
+    for (let i = 0; i < 16; ++i) {
+      const i16 = i * 16;
+      for (let j = 0; j < 16; ++j) {
+        table[i16 + j] = alphabet[i] + alphabet[j];
+      }
+    }
+    return table;
+  })();
+  function defineBigIntMethod(fn) {
+    return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+  }
+  function BufferBigIntNotDefined() {
+    throw new Error("BigInt not supported");
+  }
+  return exports;
+}
+
+// node_modules/@jspm/core/nodelibs/browser/buffer.js
+var exports2 = dew();
+exports2["Buffer"];
+exports2["SlowBuffer"];
+exports2["INSPECT_MAX_BYTES"];
+exports2["kMaxLength"];
+var Buffer2 = exports2.Buffer;
+var INSPECT_MAX_BYTES = exports2.INSPECT_MAX_BYTES;
+var kMaxLength = exports2.kMaxLength;
+
+// node_modules/@typespec/ts-http-runtime/dist/browser/util/bytesEncoding.common.js
+var hexDigits = new Set("0123456789abcdefABCDEF");
+
+// node_modules/@typespec/ts-http-runtime/dist/browser/util/uuidUtils.common.js
+function generateUUID() {
+  let uuid = "";
+  for (let i = 0; i < 32; i++) {
+    const randomNumber = Math.floor(Math.random() * 16);
+    if (i === 12) {
+      uuid += "4";
+    } else if (i === 16) {
+      uuid += (randomNumber & 3 | 8).toString(16);
+    } else {
+      uuid += randomNumber.toString(16);
+    }
+    if (i === 7 || i === 11 || i === 15 || i === 19) {
+      uuid += "-";
+    }
+  }
+  return uuid;
+}
+
+// node_modules/@typespec/ts-http-runtime/dist/browser/util/uuidUtils-browser.mjs
+var uuidFunction = typeof globalThis?.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID.bind(globalThis.crypto) : generateUUID;
+
+// node_modules/@typespec/ts-http-runtime/dist/browser/env-browser.mjs
+function getEnvironmentVariable(name2) {
+  return globalThis.process?.env?.[name2];
+}
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var isWebWorker = typeof self === "object" && "importScripts" in self && typeof self.importScripts === "function" && (self.constructor?.name === "DedicatedWorkerGlobalScope" || self.constructor?.name === "ServiceWorkerGlobalScope" || self.constructor?.name === "SharedWorkerGlobalScope");
+
+// node_modules/@azure/abort-controller/dist/browser/AbortError.js
+var AbortError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+
+// node_modules/@azure/core-util/dist/browser/createAbortablePromise.js
+function createAbortablePromise(buildPromise, options) {
+  const { cleanupBeforeAbort, abortSignal, abortErrorMsg } = options ?? {};
+  return new Promise((resolve, reject) => {
+    function rejectOnAbort() {
+      reject(new AbortError(abortErrorMsg ?? "The operation was aborted."));
+    }
+    function removeListeners() {
+      abortSignal?.removeEventListener("abort", onAbort);
+    }
+    function onAbort() {
+      cleanupBeforeAbort?.();
+      removeListeners();
+      rejectOnAbort();
+    }
+    if (abortSignal?.aborted) {
+      return rejectOnAbort();
+    }
+    try {
+      buildPromise((x) => {
+        removeListeners();
+        resolve(x);
+      }, (x) => {
+        removeListeners();
+        reject(x);
+      });
+    } catch (err) {
+      reject(err);
+    }
+    abortSignal?.addEventListener("abort", onAbort);
+  });
+}
+
+// node_modules/@azure/core-util/dist/browser/delay.js
+var StandardAbortMessage = "The delay was aborted.";
+function delay(timeInMs, options) {
+  let token;
+  const { abortSignal, abortErrorMsg } = options ?? {};
+  return createAbortablePromise((resolve) => {
+    token = setTimeout(resolve, timeInMs);
+  }, {
+    cleanupBeforeAbort: () => clearTimeout(token),
+    abortSignal,
+    abortErrorMsg: abortErrorMsg ?? StandardAbortMessage
+  });
+}
+
+// node_modules/@jspm/core/nodelibs/browser/events.js
+var exports$12 = {};
+var _dewExec2 = false;
+function dew2() {
+  if (_dewExec2) return exports$12;
+  _dewExec2 = true;
+  var R = typeof Reflect === "object" ? Reflect : null;
+  var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
+    return Function.prototype.apply.call(target, receiver, args);
+  };
+  var ReflectOwnKeys;
+  if (R && typeof R.ownKeys === "function") {
+    ReflectOwnKeys = R.ownKeys;
+  } else if (Object.getOwnPropertySymbols) {
+    ReflectOwnKeys = function ReflectOwnKeys2(target) {
+      return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+    };
+  } else {
+    ReflectOwnKeys = function ReflectOwnKeys2(target) {
+      return Object.getOwnPropertyNames(target);
+    };
+  }
+  function ProcessEmitWarning(warning) {
+    if (console && console.warn) console.warn(warning);
+  }
+  var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
+    return value !== value;
+  };
+  function EventEmitter2() {
+    EventEmitter2.init.call(this);
+  }
+  exports$12 = EventEmitter2;
+  exports$12.once = once2;
+  EventEmitter2.EventEmitter = EventEmitter2;
+  EventEmitter2.prototype._events = void 0;
+  EventEmitter2.prototype._eventsCount = 0;
+  EventEmitter2.prototype._maxListeners = void 0;
+  var defaultMaxListeners2 = 10;
+  function checkListener(listener) {
+    if (typeof listener !== "function") {
+      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+    }
+  }
+  Object.defineProperty(EventEmitter2, "defaultMaxListeners", {
+    enumerable: true,
+    get: function() {
+      return defaultMaxListeners2;
+    },
+    set: function(arg) {
+      if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+      }
+      defaultMaxListeners2 = arg;
+    }
+  });
+  EventEmitter2.init = function() {
+    if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+    }
+    this._maxListeners = this._maxListeners || void 0;
+  };
+  EventEmitter2.prototype.setMaxListeners = function setMaxListeners(n) {
+    if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+    }
+    this._maxListeners = n;
+    return this;
+  };
+  function _getMaxListeners(that) {
+    if (that._maxListeners === void 0) return EventEmitter2.defaultMaxListeners;
+    return that._maxListeners;
+  }
+  EventEmitter2.prototype.getMaxListeners = function getMaxListeners() {
+    return _getMaxListeners(this);
+  };
+  EventEmitter2.prototype.emit = function emit(type) {
+    var args = [];
+    for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+    var doError = type === "error";
+    var events = this._events;
+    if (events !== void 0) doError = doError && events.error === void 0;
+    else if (!doError) return false;
+    if (doError) {
+      var er;
+      if (args.length > 0) er = args[0];
+      if (er instanceof Error) {
+        throw er;
+      }
+      var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+      err.context = er;
+      throw err;
+    }
+    var handler = events[type];
+    if (handler === void 0) return false;
+    if (typeof handler === "function") {
+      ReflectApply(handler, this, args);
+    } else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
+    }
+    return true;
+  };
+  function _addListener(target, type, listener, prepend) {
+    var m;
+    var events;
+    var existing;
+    checkListener(listener);
+    events = target._events;
+    if (events === void 0) {
+      events = target._events = /* @__PURE__ */ Object.create(null);
+      target._eventsCount = 0;
+    } else {
+      if (events.newListener !== void 0) {
+        target.emit("newListener", type, listener.listener ? listener.listener : listener);
+        events = target._events;
+      }
+      existing = events[type];
+    }
+    if (existing === void 0) {
+      existing = events[type] = listener;
+      ++target._eventsCount;
+    } else {
+      if (typeof existing === "function") {
+        existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+      } else if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+      m = _getMaxListeners(target);
+      if (m > 0 && existing.length > m && !existing.warned) {
+        existing.warned = true;
+        var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+        w.name = "MaxListenersExceededWarning";
+        w.emitter = target;
+        w.type = type;
+        w.count = existing.length;
+        ProcessEmitWarning(w);
+      }
+    }
+    return target;
+  }
+  EventEmitter2.prototype.addListener = function addListener(type, listener) {
+    return _addListener(this, type, listener, false);
+  };
+  EventEmitter2.prototype.on = EventEmitter2.prototype.addListener;
+  EventEmitter2.prototype.prependListener = function prependListener(type, listener) {
+    return _addListener(this, type, listener, true);
+  };
+  function onceWrapper() {
+    if (!this.fired) {
+      this.target.removeListener(this.type, this.wrapFn);
+      this.fired = true;
+      if (arguments.length === 0) return this.listener.call(this.target);
+      return this.listener.apply(this.target, arguments);
+    }
+  }
+  function _onceWrap(target, type, listener) {
+    var state = {
+      fired: false,
+      wrapFn: void 0,
+      target,
+      type,
+      listener
+    };
+    var wrapped = onceWrapper.bind(state);
+    wrapped.listener = listener;
+    state.wrapFn = wrapped;
+    return wrapped;
+  }
+  EventEmitter2.prototype.once = function once3(type, listener) {
+    checkListener(listener);
+    this.on(type, _onceWrap(this, type, listener));
+    return this;
+  };
+  EventEmitter2.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+    checkListener(listener);
+    this.prependListener(type, _onceWrap(this, type, listener));
+    return this;
+  };
+  EventEmitter2.prototype.removeListener = function removeListener(type, listener) {
+    var list, events, position, i, originalListener;
+    checkListener(listener);
+    events = this._events;
+    if (events === void 0) return this;
+    list = events[type];
+    if (list === void 0) return this;
+    if (list === listener || list.listener === listener) {
+      if (--this._eventsCount === 0) this._events = /* @__PURE__ */ Object.create(null);
+      else {
+        delete events[type];
+        if (events.removeListener) this.emit("removeListener", type, list.listener || listener);
+      }
+    } else if (typeof list !== "function") {
+      position = -1;
+      for (i = list.length - 1; i >= 0; i--) {
+        if (list[i] === listener || list[i].listener === listener) {
+          originalListener = list[i].listener;
+          position = i;
+          break;
+        }
+      }
+      if (position < 0) return this;
+      if (position === 0) list.shift();
+      else {
+        spliceOne(list, position);
+      }
+      if (list.length === 1) events[type] = list[0];
+      if (events.removeListener !== void 0) this.emit("removeListener", type, originalListener || listener);
+    }
+    return this;
+  };
+  EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+  EventEmitter2.prototype.removeAllListeners = function removeAllListeners(type) {
+    var listeners, events, i;
+    events = this._events;
+    if (events === void 0) return this;
+    if (events.removeListener === void 0) {
+      if (arguments.length === 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      } else if (events[type] !== void 0) {
+        if (--this._eventsCount === 0) this._events = /* @__PURE__ */ Object.create(null);
+        else delete events[type];
+      }
+      return this;
+    }
+    if (arguments.length === 0) {
+      var keys = Object.keys(events);
+      var key;
+      for (i = 0; i < keys.length; ++i) {
+        key = keys[i];
+        if (key === "removeListener") continue;
+        this.removeAllListeners(key);
+      }
+      this.removeAllListeners("removeListener");
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+      return this;
+    }
+    listeners = events[type];
+    if (typeof listeners === "function") {
+      this.removeListener(type, listeners);
+    } else if (listeners !== void 0) {
+      for (i = listeners.length - 1; i >= 0; i--) {
+        this.removeListener(type, listeners[i]);
+      }
+    }
+    return this;
+  };
+  function _listeners(target, type, unwrap) {
+    var events = target._events;
+    if (events === void 0) return [];
+    var evlistener = events[type];
+    if (evlistener === void 0) return [];
+    if (typeof evlistener === "function") return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+    return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+  }
+  EventEmitter2.prototype.listeners = function listeners(type) {
+    return _listeners(this, type, true);
+  };
+  EventEmitter2.prototype.rawListeners = function rawListeners(type) {
+    return _listeners(this, type, false);
+  };
+  EventEmitter2.listenerCount = function(emitter, type) {
+    if (typeof emitter.listenerCount === "function") {
+      return emitter.listenerCount(type);
+    } else {
+      return listenerCount2.call(emitter, type);
+    }
+  };
+  EventEmitter2.prototype.listenerCount = listenerCount2;
+  function listenerCount2(type) {
+    var events = this._events;
+    if (events !== void 0) {
+      var evlistener = events[type];
+      if (typeof evlistener === "function") {
+        return 1;
+      } else if (evlistener !== void 0) {
+        return evlistener.length;
+      }
+    }
+    return 0;
+  }
+  EventEmitter2.prototype.eventNames = function eventNames() {
+    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+  };
+  function arrayClone(arr, n) {
+    var copy = new Array(n);
+    for (var i = 0; i < n; ++i) copy[i] = arr[i];
+    return copy;
+  }
+  function spliceOne(list, index) {
+    for (; index + 1 < list.length; index++) list[index] = list[index + 1];
+    list.pop();
+  }
+  function unwrapListeners(arr) {
+    var ret = new Array(arr.length);
+    for (var i = 0; i < ret.length; ++i) {
+      ret[i] = arr[i].listener || arr[i];
+    }
+    return ret;
+  }
+  function once2(emitter, name2) {
+    return new Promise(function(resolve, reject) {
+      function errorListener(err) {
+        emitter.removeListener(name2, resolver);
+        reject(err);
+      }
+      function resolver() {
+        if (typeof emitter.removeListener === "function") {
+          emitter.removeListener("error", errorListener);
+        }
+        resolve([].slice.call(arguments));
+      }
+      eventTargetAgnosticAddListener(emitter, name2, resolver, {
+        once: true
+      });
+      if (name2 !== "error") {
+        addErrorHandlerIfEventEmitter(emitter, errorListener, {
+          once: true
+        });
+      }
+    });
+  }
+  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+    if (typeof emitter.on === "function") {
+      eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+    }
+  }
+  function eventTargetAgnosticAddListener(emitter, name2, listener, flags) {
+    if (typeof emitter.on === "function") {
+      if (flags.once) {
+        emitter.once(name2, listener);
+      } else {
+        emitter.on(name2, listener);
+      }
+    } else if (typeof emitter.addEventListener === "function") {
+      emitter.addEventListener(name2, function wrapListener(arg) {
+        if (flags.once) {
+          emitter.removeEventListener(name2, wrapListener);
+        }
+        listener(arg);
+      });
+    } else {
+      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+    }
+  }
+  return exports$12;
+}
+var exports3 = dew2();
+exports3["once"];
+exports3.once = function(emitter, event) {
+  return new Promise((resolve, reject) => {
+    function eventListener(...args) {
+      if (errorListener !== void 0) {
+        emitter.removeListener("error", errorListener);
+      }
+      resolve(args);
+    }
+    let errorListener;
+    if (event !== "error") {
+      errorListener = (err) => {
+        emitter.removeListener(name, eventListener);
+        reject(err);
+      };
+      emitter.once("error", errorListener);
+    }
+    emitter.once(event, eventListener);
+  });
+};
+exports3.on = function(emitter, event) {
+  const unconsumedEventValues = [];
+  const unconsumedPromises = [];
+  let error = null;
+  let finished = false;
+  const iterator = {
+    async next() {
+      const value = unconsumedEventValues.shift();
+      if (value) {
+        return createIterResult(value, false);
+      }
+      if (error) {
+        const p = Promise.reject(error);
+        error = null;
+        return p;
+      }
+      if (finished) {
+        return createIterResult(void 0, true);
+      }
+      return new Promise((resolve, reject) => unconsumedPromises.push({ resolve, reject }));
+    },
+    async return() {
+      emitter.removeListener(event, eventHandler);
+      emitter.removeListener("error", errorHandler);
+      finished = true;
+      for (const promise of unconsumedPromises) {
+        promise.resolve(createIterResult(void 0, true));
+      }
+      return createIterResult(void 0, true);
+    },
+    throw(err) {
+      error = err;
+      emitter.removeListener(event, eventHandler);
+      emitter.removeListener("error", errorHandler);
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+  emitter.on(event, eventHandler);
+  emitter.on("error", errorHandler);
+  return iterator;
+  function eventHandler(...args) {
+    const promise = unconsumedPromises.shift();
+    if (promise) {
+      promise.resolve(createIterResult(args, false));
+    } else {
+      unconsumedEventValues.push(args);
+    }
+  }
+  function errorHandler(err) {
+    finished = true;
+    const toError = unconsumedPromises.shift();
+    if (toError) {
+      toError.reject(err);
+    } else {
+      error = err;
+    }
+    iterator.return();
+  }
+};
+var {
+  EventEmitter,
+  defaultMaxListeners,
+  init,
+  listenerCount,
+  on,
+  once
+} = exports3;
+
+// node_modules/@azure/web-pubsub-client/dist/browser/errors/index.js
+var SendMessageError = class extends Error {
+  /**
+   * Initialize a SendMessageError
+   * @param message - The error message
+   * @param ackMessage - The ack message
+   */
+  constructor(message, options) {
+    super(message);
+    /**
+     * Error name
+     */
+    __publicField(this, "name");
+    /**
+     * The ack id of the message
+     */
+    __publicField(this, "ackId");
+    /**
+     * The error details from the service
+     */
+    __publicField(this, "errorDetail");
+    this.name = "SendMessageError";
+    this.ackId = options.ackId;
+    this.errorDetail = options.errorDetail;
+  }
+};
+var InvocationError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    /**
+     * The invocation id of the request.
+     */
+    __publicField(this, "invocationId");
+    /**
+     * Error details from the service if available.
+     */
+    __publicField(this, "errorDetail");
+    this.name = "InvocationError";
+    this.invocationId = options.invocationId;
+    this.errorDetail = options.errorDetail;
+  }
+};
+
+// node_modules/@typespec/ts-http-runtime/dist/browser/logger/log.common.js
+function log(...args) {
+  if (args.length > 0) {
+    const firstArg = String(args[0]);
+    if (firstArg.includes(":error")) {
+      console.error(...args);
+    } else if (firstArg.includes(":warning")) {
+      console.warn(...args);
+    } else if (firstArg.includes(":info")) {
+      console.info(...args);
+    } else if (firstArg.includes(":verbose")) {
+      console.debug(...args);
+    } else {
+      console.debug(...args);
+    }
+  }
+}
+
+// node_modules/@typespec/ts-http-runtime/dist/browser/logger/debug.js
+var debugEnvVariable = getEnvironmentVariable("DEBUG");
+var enabledString;
+var enabledNamespaces = [];
+var skippedNamespaces = [];
+var debuggers = [];
+if (debugEnvVariable) {
+  enable(debugEnvVariable);
+}
+var debugObj = Object.assign((namespace) => {
+  return createDebugger(namespace);
+}, {
+  enable,
+  enabled,
+  disable,
+  log
+});
+function enable(namespaces) {
+  enabledString = namespaces;
+  enabledNamespaces = [];
+  skippedNamespaces = [];
+  const namespaceList = namespaces.split(",").map((ns) => ns.trim());
+  for (const ns of namespaceList) {
+    if (ns.startsWith("-")) {
+      skippedNamespaces.push(ns.substring(1));
+    } else {
+      enabledNamespaces.push(ns);
+    }
+  }
+  for (const instance of debuggers) {
+    instance.enabled = enabled(instance.namespace);
+  }
+}
+function enabled(namespace) {
+  if (namespace.endsWith("*")) {
+    return true;
+  }
+  for (const skipped of skippedNamespaces) {
+    if (namespaceMatches(namespace, skipped)) {
+      return false;
+    }
+  }
+  for (const enabledNamespace of enabledNamespaces) {
+    if (namespaceMatches(namespace, enabledNamespace)) {
+      return true;
+    }
+  }
+  return false;
+}
+function namespaceMatches(namespace, patternToMatch) {
+  if (patternToMatch.indexOf("*") === -1) {
+    return namespace === patternToMatch;
+  }
+  let pattern = patternToMatch;
+  if (patternToMatch.indexOf("**") !== -1) {
+    const patternParts = [];
+    let lastCharacter = "";
+    for (const character of patternToMatch) {
+      if (character === "*" && lastCharacter === "*") {
+        continue;
+      } else {
+        lastCharacter = character;
+        patternParts.push(character);
+      }
+    }
+    pattern = patternParts.join("");
+  }
+  let namespaceIndex = 0;
+  let patternIndex = 0;
+  const patternLength = pattern.length;
+  const namespaceLength = namespace.length;
+  let lastWildcard = -1;
+  let lastWildcardNamespace = -1;
+  while (namespaceIndex < namespaceLength && patternIndex < patternLength) {
+    if (pattern[patternIndex] === "*") {
+      lastWildcard = patternIndex;
+      patternIndex++;
+      if (patternIndex === patternLength) {
+        return true;
+      }
+      while (namespace[namespaceIndex] !== pattern[patternIndex]) {
+        namespaceIndex++;
+        if (namespaceIndex === namespaceLength) {
+          return false;
+        }
+      }
+      lastWildcardNamespace = namespaceIndex;
+      namespaceIndex++;
+      patternIndex++;
+      continue;
+    } else if (pattern[patternIndex] === namespace[namespaceIndex]) {
+      patternIndex++;
+      namespaceIndex++;
+    } else if (lastWildcard >= 0) {
+      patternIndex = lastWildcard + 1;
+      namespaceIndex = lastWildcardNamespace + 1;
+      if (namespaceIndex === namespaceLength) {
+        return false;
+      }
+      while (namespace[namespaceIndex] !== pattern[patternIndex]) {
+        namespaceIndex++;
+        if (namespaceIndex === namespaceLength) {
+          return false;
+        }
+      }
+      lastWildcardNamespace = namespaceIndex;
+      namespaceIndex++;
+      patternIndex++;
+      continue;
+    } else {
+      return false;
+    }
+  }
+  const namespaceDone = namespaceIndex === namespace.length;
+  const patternDone = patternIndex === pattern.length;
+  const trailingWildCard = patternIndex === pattern.length - 1 && pattern[patternIndex] === "*";
+  return namespaceDone && (patternDone || trailingWildCard);
+}
+function disable() {
+  const result = enabledString || "";
+  enable("");
+  return result;
+}
+function createDebugger(namespace) {
+  const newDebugger = Object.assign(debug, {
+    enabled: enabled(namespace),
+    destroy,
+    log: debugObj.log,
+    namespace,
+    extend
+  });
+  function debug(...args) {
+    if (!newDebugger.enabled) {
+      return;
+    }
+    if (args.length > 0) {
+      args[0] = `${namespace} ${args[0]}`;
+    }
+    newDebugger.log(...args);
+  }
+  debuggers.push(newDebugger);
+  return newDebugger;
+}
+function destroy() {
+  const index = debuggers.indexOf(this);
+  if (index >= 0) {
+    debuggers.splice(index, 1);
+    return true;
+  }
+  return false;
+}
+function extend(namespace) {
+  const newDebugger = createDebugger(`${this.namespace}:${namespace}`);
+  newDebugger.log = this.log;
+  return newDebugger;
+}
+var debug_default = debugObj;
+
+// node_modules/@typespec/ts-http-runtime/dist/browser/logger/logger.js
+var TYPESPEC_RUNTIME_LOG_LEVELS = ["verbose", "info", "warning", "error"];
+var levelMap = {
+  verbose: 400,
+  info: 300,
+  warning: 200,
+  error: 100
+};
+function patchLogMethod(parent, child) {
+  child.log = (...args) => {
+    parent.log(...args);
+  };
+}
+function isTypeSpecRuntimeLogLevel(level) {
+  return TYPESPEC_RUNTIME_LOG_LEVELS.includes(level);
+}
+function createLoggerContext(options) {
+  const registeredLoggers = /* @__PURE__ */ new Set();
+  const logLevelFromEnv = getEnvironmentVariable(options.logLevelEnvVarName);
+  let logLevel;
+  const clientLogger = debug_default(options.namespace);
+  clientLogger.log = (...args) => {
+    debug_default.log(...args);
+  };
+  function contextSetLogLevel(level) {
+    if (level && !isTypeSpecRuntimeLogLevel(level)) {
+      throw new Error(`Unknown log level '${level}'. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(",")}`);
+    }
+    logLevel = level;
+    const enabledNamespaces2 = [];
+    for (const logger3 of registeredLoggers) {
+      if (shouldEnable(logger3)) {
+        enabledNamespaces2.push(logger3.namespace);
+      }
+    }
+    debug_default.enable(enabledNamespaces2.join(","));
+  }
+  if (logLevelFromEnv) {
+    if (isTypeSpecRuntimeLogLevel(logLevelFromEnv)) {
+      contextSetLogLevel(logLevelFromEnv);
+    } else {
+      console.error(`${options.logLevelEnvVarName} set to unknown log level '${logLevelFromEnv}'; logging is not enabled. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(", ")}.`);
+    }
+  }
+  function shouldEnable(logger3) {
+    return Boolean(logLevel && levelMap[logger3.level] <= levelMap[logLevel]);
+  }
+  function createLogger(parent, level) {
+    const logger3 = Object.assign(parent.extend(level), {
+      level
+    });
+    patchLogMethod(parent, logger3);
+    if (shouldEnable(logger3)) {
+      const enabledNamespaces2 = debug_default.disable();
+      debug_default.enable(enabledNamespaces2 + "," + logger3.namespace);
+    }
+    registeredLoggers.add(logger3);
+    return logger3;
+  }
+  function contextGetLogLevel() {
+    return logLevel;
+  }
+  function contextCreateClientLogger(namespace) {
+    const clientRootLogger = clientLogger.extend(namespace);
+    patchLogMethod(clientLogger, clientRootLogger);
+    return {
+      error: createLogger(clientRootLogger, "error"),
+      warning: createLogger(clientRootLogger, "warning"),
+      info: createLogger(clientRootLogger, "info"),
+      verbose: createLogger(clientRootLogger, "verbose")
+    };
+  }
+  return {
+    setLogLevel: contextSetLogLevel,
+    getLogLevel: contextGetLogLevel,
+    createClientLogger: contextCreateClientLogger,
+    logger: clientLogger
+  };
+}
+var context = createLoggerContext({
+  logLevelEnvVarName: "TYPESPEC_RUNTIME_LOG_LEVEL",
+  namespace: "typeSpecRuntime"
+});
+var TypeSpecRuntimeLogger = context.logger;
+
+// node_modules/@azure/logger/dist/browser/index.js
+var context2 = createLoggerContext({
+  logLevelEnvVarName: "AZURE_LOG_LEVEL",
+  namespace: "azure"
+});
+var AzureLogger = context2.logger;
+function createClientLogger(namespace) {
+  return context2.createClientLogger(namespace);
+}
+
+// node_modules/@azure/web-pubsub-client/dist/browser/logger.js
+var logger = createClientLogger("web-pubsub-client");
+
+// node_modules/@azure/web-pubsub-client/dist/browser/protocols/jsonProtocolBase.js
+function parseMessages(input) {
+  if (typeof input !== "string") {
+    throw new Error("Invalid input for JSON hub protocol. Expected a string.");
+  }
+  if (!input) {
+    throw new Error("No input");
+  }
+  const parsedMessage = JSON.parse(input);
+  const typedMessage = parsedMessage;
+  let returnMessage;
+  if (typedMessage.type === "system") {
+    if (typedMessage.event === "connected") {
+      returnMessage = { ...parsedMessage, kind: "connected" };
+    } else if (typedMessage.event === "disconnected") {
+      returnMessage = { ...parsedMessage, kind: "disconnected" };
+    } else {
+      return null;
+    }
+  } else if (typedMessage.type === "message") {
+    if (typedMessage.from === "group") {
+      const data = parsePayload(parsedMessage.data, parsedMessage.dataType);
+      if (data === null) {
+        return null;
+      }
+      returnMessage = { ...parsedMessage, data, kind: "groupData" };
+    } else if (typedMessage.from === "server") {
+      const data = parsePayload(parsedMessage.data, parsedMessage.dataType);
+      if (data === null) {
+        return null;
+      }
+      returnMessage = {
+        ...parsedMessage,
+        data,
+        kind: "serverData"
+      };
+    } else {
+      return null;
+    }
+  } else if (typedMessage.type === "ack") {
+    returnMessage = { ...parsedMessage, kind: "ack" };
+  } else if (typedMessage.type === "invokeResponse") {
+    let data;
+    if (parsedMessage.dataType != null) {
+      const parsedData = parsePayload(parsedMessage.data, parsedMessage.dataType);
+      if (parsedData === null) {
+        return null;
+      }
+      data = parsedData;
+    }
+    returnMessage = {
+      kind: "invokeResponse",
+      invocationId: parsedMessage.invocationId,
+      success: parsedMessage.success,
+      dataType: parsedMessage.dataType,
+      data,
+      error: parsedMessage.error
+    };
+  } else if (typedMessage.type === "cancelInvocation") {
+    returnMessage = {
+      ...parsedMessage,
+      kind: "cancelInvocation"
+    };
+  } else if (typedMessage.type === "pong") {
+    returnMessage = { ...parsedMessage, kind: "pong" };
+  } else {
+    return null;
+  }
+  return returnMessage;
+}
+function writeMessage(message) {
+  let data;
+  switch (message.kind) {
+    case "joinGroup": {
+      data = { type: "joinGroup", group: message.group, ackId: message.ackId };
+      break;
+    }
+    case "leaveGroup": {
+      data = { type: "leaveGroup", group: message.group, ackId: message.ackId };
+      break;
+    }
+    case "sendEvent": {
+      data = {
+        type: "event",
+        event: message.event,
+        ackId: message.ackId,
+        dataType: message.dataType,
+        data: getPayload(message.data, message.dataType)
+      };
+      break;
+    }
+    case "sendToGroup": {
+      data = {
+        type: "sendToGroup",
+        group: message.group,
+        ackId: message.ackId,
+        dataType: message.dataType,
+        data: getPayload(message.data, message.dataType),
+        noEcho: message.noEcho
+      };
+      break;
+    }
+    case "sequenceAck": {
+      data = { type: "sequenceAck", sequenceId: message.sequenceId };
+      break;
+    }
+    case "invoke": {
+      const invokePayload = {
+        type: "invoke",
+        invocationId: message.invocationId,
+        target: message.target,
+        event: message.event
+      };
+      if (message.dataType != null && message.data != null) {
+        invokePayload.dataType = message.dataType;
+        invokePayload.data = getPayload(message.data, message.dataType);
+      }
+      data = invokePayload;
+      break;
+    }
+    case "invokeResponse": {
+      const invokeResponse = {
+        type: "invokeResponse",
+        invocationId: message.invocationId,
+        success: message.success,
+        error: message.error
+      };
+      if (message.dataType != null && message.data != null) {
+        invokeResponse.dataType = message.dataType;
+        invokeResponse.data = getPayload(message.data, message.dataType);
+      }
+      data = invokeResponse;
+      break;
+    }
+    case "cancelInvocation": {
+      data = {
+        type: "cancelInvocation",
+        invocationId: message.invocationId
+      };
+      break;
+    }
+    case "ping": {
+      data = { type: "ping" };
+      break;
+    }
+    default: {
+      throw new Error(`Unsupported type: ${message.kind}`);
+    }
+  }
+  return JSON.stringify(data);
+}
+function getPayload(data, dataType) {
+  switch (dataType) {
+    case "text": {
+      if (typeof data !== "string") {
+        throw new TypeError("Message must be a string.");
+      }
+      return data;
+    }
+    case "json": {
+      return data;
+    }
+    case "binary":
+    case "protobuf": {
+      if (data instanceof ArrayBuffer) {
+        return Buffer2.from(data).toString("base64");
+      }
+      throw new TypeError("Message must be a ArrayBuffer");
+    }
+  }
+}
+function parsePayload(data, dataType) {
+  if (dataType === "text") {
+    if (typeof data !== "string") {
+      throw new TypeError("Message must be a string when dataType is text");
+    }
+    return data;
+  } else if (dataType === "json") {
+    return data;
+  } else if (dataType === "binary" || dataType === "protobuf") {
+    const buf = Buffer2.from(data, "base64");
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  } else {
+    return null;
+  }
+}
+
+// node_modules/@azure/web-pubsub-client/dist/browser/protocols/webPubSubJsonReliableProtocol.js
+var WebPubSubJsonReliableProtocolImpl = class {
+  constructor() {
+    /**
+     * True if the protocol supports reliable features
+     */
+    __publicField(this, "isReliableSubProtocol", true);
+    /**
+     * The name of subprotocol. Name will be used in websocket subprotocol
+     */
+    __publicField(this, "name", "json.reliable.webpubsub.azure.v1");
+  }
+  /**
+   * Creates WebPubSubMessage objects from the specified serialized representation.
+   * @param input - The serialized representation
+   */
+  parseMessages(input) {
+    return parseMessages(input);
+  }
+  /**
+   * Write WebPubSubMessage to string
+   * @param message - The message to be written
+   */
+  writeMessage(message) {
+    return writeMessage(message);
+  }
+};
+
+// node_modules/@azure/web-pubsub-client/dist/browser/protocols/index.js
+var WebPubSubJsonReliableProtocol = () => {
+  return new WebPubSubJsonReliableProtocolImpl();
+};
+
+// node_modules/@azure/web-pubsub-client/dist/browser/websocket/websocketClient.js
+var WebSocketClient = class {
+  constructor(uri, protocolName) {
+    __publicField(this, "_socket");
+    this._socket = new WebSocket(uri, protocolName);
+    this._socket.binaryType = "arraybuffer";
+  }
+  onopen(fn) {
+    this._socket.onopen = fn;
+  }
+  onclose(fn) {
+    this._socket.onclose = (ev) => fn(ev.code, ev.reason);
+  }
+  onerror(fn) {
+    this._socket.onerror = (ev) => fn(ev);
+  }
+  onmessage(fn) {
+    this._socket.onmessage = (event) => fn(event.data);
+  }
+  close(code, reason) {
+    this._socket.close(code, reason);
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  send(data, _) {
+    return new Promise((resolve, reject) => {
+      try {
+        this._socket.send(data);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  isOpen() {
+    return this._socket.readyState === WebSocket.OPEN;
+  }
+};
+var WebSocketClientFactory = class {
+  create(uri, protocolName) {
+    return new WebSocketClient(uri, protocolName);
+  }
+};
+
+// node_modules/@azure/web-pubsub-client/dist/browser/utils/abortablePromise.js
+async function abortablePromise(promise, signal) {
+  if (signal.aborted) {
+    throw new AbortError("The operation was aborted.");
+  }
+  let onAbort;
+  const p = new Promise((_, reject) => {
+    onAbort = () => {
+      reject(new AbortError("The operation was aborted."));
+    };
+    signal.addEventListener("abort", onAbort);
+  });
+  try {
+    return await Promise.race([promise, p]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+
+// node_modules/@azure/web-pubsub-client/dist/browser/ackManager.js
+var AckManager = class {
+  constructor(initialAckId = 0) {
+    __publicField(this, "_ackEntries", /* @__PURE__ */ new Map());
+    __publicField(this, "_ackId");
+    this._ackId = initialAckId;
+  }
+  registerAck(ackId) {
+    const resolvedAckId = ackId ?? this._generateAckId();
+    let entry = this._ackEntries.get(resolvedAckId);
+    if (!entry) {
+      entry = new AckEntity(resolvedAckId);
+      this._ackEntries.set(resolvedAckId, entry);
+    }
+    const ackEntry = entry;
+    return {
+      ackId: resolvedAckId,
+      wait: (abortSignal) => this._waitForEntry(ackEntry, abortSignal)
+    };
+  }
+  resolveAck(ackId, result) {
+    const entry = this._ackEntries.get(ackId);
+    if (!entry) {
+      return false;
+    }
+    this._ackEntries.delete(ackId);
+    entry.resolve(result);
+    return true;
+  }
+  rejectAck(ackId, reason) {
+    const entry = this._ackEntries.get(ackId);
+    if (!entry) {
+      return false;
+    }
+    this._ackEntries.delete(ackId);
+    entry.reject(reason);
+    return true;
+  }
+  discard(ackId) {
+    this._ackEntries.delete(ackId);
+  }
+  rejectAll(createReason) {
+    this._ackEntries.forEach((entry, ackId) => {
+      if (this._ackEntries.delete(ackId)) {
+        entry.reject(createReason(ackId));
+      }
+    });
+  }
+  _waitForEntry(entry, abortSignal) {
+    if (!abortSignal) {
+      return entry.promise();
+    }
+    return abortablePromise(entry.promise(), abortSignal).catch((err) => {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new SendMessageError("Cancelled by abortSignal", { ackId: entry.ackId });
+      }
+      throw err;
+    });
+  }
+  _generateAckId() {
+    this._ackId += 1;
+    return this._ackId;
+  }
+};
+var AckEntity = class {
+  constructor(ackId) {
+    __publicField(this, "ackId");
+    __publicField(this, "_promise");
+    __publicField(this, "_resolve");
+    __publicField(this, "_reject");
+    this.ackId = ackId;
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  promise() {
+    return this._promise;
+  }
+  resolve(value) {
+    const callback = this._resolve;
+    if (!callback) {
+      return;
+    }
+    this._resolve = void 0;
+    this._reject = void 0;
+    callback(value);
+  }
+  reject(reason) {
+    const callback = this._reject;
+    if (!callback) {
+      return;
+    }
+    this._resolve = void 0;
+    this._reject = void 0;
+    callback(reason);
+  }
+};
+
+// node_modules/@azure/web-pubsub-client/dist/browser/invocationManager.js
+var InvocationManager = class {
+  constructor() {
+    __publicField(this, "_entries", /* @__PURE__ */ new Map());
+    __publicField(this, "_nextId", 0);
+  }
+  registerInvocation(invocationId) {
+    const resolvedId = invocationId ?? this._generateInvocationId();
+    if (this._entries.has(resolvedId)) {
+      throw new InvocationError("Invocation id is already registered.", {
+        invocationId: resolvedId
+      });
+    }
+    const entity = new InvocationEntity(resolvedId);
+    this._entries.set(resolvedId, entity);
+    return {
+      invocationId: resolvedId,
+      wait: (options) => this._waitForEntry(entity, options)
+    };
+  }
+  resolveInvocation(message) {
+    const entry = this._entries.get(message.invocationId);
+    if (!entry) {
+      return false;
+    }
+    this._entries.delete(message.invocationId);
+    entry.resolve(message);
+    return true;
+  }
+  rejectInvocation(invocationId, reason) {
+    const entry = this._entries.get(invocationId);
+    if (!entry) {
+      return false;
+    }
+    this._entries.delete(invocationId);
+    entry.reject(reason);
+    return true;
+  }
+  discard(invocationId) {
+    this._entries.delete(invocationId);
+  }
+  rejectAll(createReason) {
+    this._entries.forEach((entry, invocationId) => {
+      if (this._entries.delete(invocationId)) {
+        entry.reject(createReason(invocationId));
+      }
+    });
+  }
+  _waitForEntry(entry, options) {
+    const waitPromise = entry.promise();
+    const abortSignal = options?.abortSignal;
+    if (!abortSignal) {
+      return waitPromise;
+    }
+    if (abortSignal.aborted) {
+      if (this._entries.delete(entry.invocationId)) {
+        entry.reject(this._createAbortError(entry.invocationId));
+      }
+      return waitPromise;
+    }
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        abortSignal.removeEventListener("abort", onAbort);
+        if (this._entries.delete(entry.invocationId)) {
+          entry.reject(this._createAbortError(entry.invocationId));
+        }
+      };
+      abortSignal.addEventListener("abort", onAbort);
+      waitPromise.then((result) => {
+        abortSignal.removeEventListener("abort", onAbort);
+        return resolve(result);
+      }).catch((err) => {
+        abortSignal.removeEventListener("abort", onAbort);
+        return reject(err);
+      });
+    });
+  }
+  _generateInvocationId() {
+    this._nextId += 1;
+    return this._nextId.toString();
+  }
+  _createAbortError(invocationId) {
+    return new InvocationError("Invocation cancelled by abortSignal.", {
+      invocationId
+    });
+  }
+};
+var InvocationEntity = class {
+  constructor(invocationId) {
+    __publicField(this, "invocationId");
+    __publicField(this, "_promise");
+    __publicField(this, "_resolve");
+    __publicField(this, "_reject");
+    this.invocationId = invocationId;
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  promise() {
+    return this._promise;
+  }
+  resolve(value) {
+    const callback = this._resolve;
+    if (!callback) {
+      return;
+    }
+    this._resolve = void 0;
+    this._reject = void 0;
+    callback(value);
+  }
+  reject(reason) {
+    const callback = this._reject;
+    if (!callback) {
+      return;
+    }
+    this._resolve = void 0;
+    this._reject = void 0;
+    callback(reason);
+  }
+};
+
+// node_modules/@azure/web-pubsub-client/dist/browser/webPubSubClient.js
+var WebPubSubClientState;
+(function(WebPubSubClientState2) {
+  WebPubSubClientState2["Stopped"] = "Stopped";
+  WebPubSubClientState2["Disconnected"] = "Disconnected";
+  WebPubSubClientState2["Connecting"] = "Connecting";
+  WebPubSubClientState2["Connected"] = "Connected";
+  WebPubSubClientState2["Recovering"] = "Recovering";
+})(WebPubSubClientState || (WebPubSubClientState = {}));
+var WebPubSubClient = class {
+  constructor(credential, options) {
+    __publicField(this, "_protocol");
+    __publicField(this, "_credential");
+    __publicField(this, "_options");
+    __publicField(this, "_groupMap");
+    __publicField(this, "_ackManager");
+    __publicField(this, "_invocationManager");
+    __publicField(this, "_sequenceId");
+    __publicField(this, "_messageRetryPolicy");
+    __publicField(this, "_reconnectRetryPolicy");
+    __publicField(this, "_quickSequenceAckDiff", 300);
+    // The timeout for keep alive
+    __publicField(this, "_keepAliveTimeoutInMs");
+    // The interval at which to send keep-alive ping messages to the runtime
+    __publicField(this, "_keepAliveIntervalInMs");
+    __publicField(this, "_emitter", new exports3());
+    __publicField(this, "_state");
+    __publicField(this, "_isStopping", false);
+    __publicField(this, "_pingKeepaliveTask");
+    __publicField(this, "_timeoutMonitorTask");
+    // connection lifetime
+    __publicField(this, "_wsClient");
+    __publicField(this, "_uri");
+    __publicField(this, "_lastCloseEvent");
+    __publicField(this, "_lastDisconnectedMessage");
+    __publicField(this, "_connectionId");
+    __publicField(this, "_reconnectionToken");
+    __publicField(this, "_isInitialConnected", false);
+    __publicField(this, "_sequenceAckTask");
+    __publicField(this, "_lastMessageReceived", Date.now());
+    if (typeof credential === "string") {
+      this._credential = { getClientAccessUrl: credential };
+    } else {
+      this._credential = credential;
+    }
+    if (options == null) {
+      options = {};
+    }
+    this._buildDefaultOptions(options);
+    this._options = options;
+    this._messageRetryPolicy = new RetryPolicy(this._options.messageRetryOptions);
+    this._reconnectRetryPolicy = new RetryPolicy(this._options.reconnectRetryOptions);
+    this._protocol = this._options.protocol;
+    this._groupMap = /* @__PURE__ */ new Map();
+    this._ackManager = new AckManager();
+    this._invocationManager = new InvocationManager();
+    this._sequenceId = new SequenceId();
+    this._keepAliveTimeoutInMs = this._options.keepAliveTimeoutInMs ?? 12e4;
+    this._keepAliveIntervalInMs = this._options.keepAliveIntervalInMs ?? 2e4;
+    this._state = WebPubSubClientState.Stopped;
+  }
+  /**
+   * Start to start to the service.
+   * @param abortSignal - The abort signal
+   */
+  async start(options) {
+    if (this._isStopping) {
+      throw new Error("Can't start a client during stopping");
+    }
+    if (this._state !== WebPubSubClientState.Stopped) {
+      throw new Error("Client can be only started when it's Stopped");
+    }
+    let abortSignal;
+    if (options) {
+      abortSignal = options.abortSignal;
+    }
+    if (!this._pingKeepaliveTask && this._keepAliveIntervalInMs > 0) {
+      this._pingKeepaliveTask = this._getPingKeepaliveTask();
+    }
+    if (!this._timeoutMonitorTask && this._keepAliveTimeoutInMs > 0) {
+      this._timeoutMonitorTask = this._getTimeoutMonitorTask();
+    }
+    try {
+      await this._startCore(abortSignal);
+    } catch (err) {
+      this._changeState(WebPubSubClientState.Stopped);
+      this._disposeKeepaliveTasks();
+      this._isStopping = false;
+      throw err;
+    }
+  }
+  async _startFromRestarting(abortSignal) {
+    if (this._state !== WebPubSubClientState.Disconnected) {
+      throw new Error("Client can be only restarted when it's Disconnected");
+    }
+    try {
+      logger.verbose("Staring reconnecting.");
+      await this._startCore(abortSignal);
+    } catch (err) {
+      this._changeState(WebPubSubClientState.Disconnected);
+      throw err;
+    }
+  }
+  async _startCore(abortSignal) {
+    this._changeState(WebPubSubClientState.Connecting);
+    logger.info("Staring a new connection");
+    this._sequenceId.reset();
+    this._isInitialConnected = false;
+    this._lastCloseEvent = void 0;
+    this._lastDisconnectedMessage = void 0;
+    this._connectionId = void 0;
+    this._reconnectionToken = void 0;
+    this._uri = void 0;
+    if (typeof this._credential.getClientAccessUrl === "string") {
+      this._uri = this._credential.getClientAccessUrl;
+    } else {
+      this._uri = await this._credential.getClientAccessUrl({
+        abortSignal
+      });
+    }
+    if (typeof this._uri !== "string") {
+      throw new Error(`The clientAccessUrl must be a string but currently it's ${typeof this._uri}`);
+    }
+    await this._connectCore(this._uri);
+  }
+  /**
+   * Stop the client.
+   */
+  stop() {
+    if (this._state === WebPubSubClientState.Stopped || this._isStopping) {
+      return;
+    }
+    this._isStopping = true;
+    if (this._wsClient && this._wsClient.isOpen()) {
+      this._wsClient.close();
+    } else {
+      this._isStopping = false;
+    }
+    this._disposeKeepaliveTasks();
+  }
+  _disposeKeepaliveTasks() {
+    if (this._pingKeepaliveTask) {
+      this._pingKeepaliveTask.abort();
+      this._pingKeepaliveTask = void 0;
+    }
+    if (this._timeoutMonitorTask) {
+      this._timeoutMonitorTask.abort();
+      this._timeoutMonitorTask = void 0;
+    }
+  }
+  on(event, listener) {
+    this._emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this._emitter.removeListener(event, listener);
+  }
+  _emitEvent(event, args) {
+    this._emitter.emit(event, args);
+  }
+  /**
+   * Send custom event to server.
+   * @param eventName - The event name
+   * @param content - The data content
+   * @param dataType - The data type
+   * @param options - The options
+   * @param abortSignal - The abort signal
+   */
+  async sendEvent(eventName, content, dataType, options) {
+    return this._operationExecuteWithRetry(() => this._sendEventAttempt(eventName, content, dataType, options), options?.abortSignal);
+  }
+  async _sendEventAttempt(eventName, content, dataType, options) {
+    const fireAndForget = options?.fireAndForget ?? false;
+    if (!fireAndForget) {
+      return this._sendMessageWithAckId((id) => {
+        return {
+          kind: "sendEvent",
+          dataType,
+          data: content,
+          ackId: id,
+          event: eventName
+        };
+      }, options?.ackId, options?.abortSignal);
+    }
+    const message = {
+      kind: "sendEvent",
+      dataType,
+      data: content,
+      event: eventName
+    };
+    await this._sendMessage(message, options?.abortSignal);
+    return { isDuplicated: false };
+  }
+  async _invokeEventAttempt(eventName, content, dataType, options) {
+    const invokeOptions = options ?? {};
+    const { invocationId, wait } = this._invocationManager.registerInvocation(invokeOptions.invocationId);
+    const invokeMessage = {
+      kind: "invoke",
+      invocationId,
+      target: "event",
+      event: eventName,
+      dataType,
+      data: content
+    };
+    const responsePromise = wait({
+      abortSignal: invokeOptions.abortSignal
+    });
+    try {
+      await this._sendMessage(invokeMessage, invokeOptions.abortSignal);
+    } catch (err) {
+      const invocationError = err instanceof InvocationError ? err : new InvocationError(err instanceof Error ? err.message : "Failed to send invocation message.", {
+        invocationId
+      });
+      this._invocationManager.rejectInvocation(invocationId, invocationError);
+      void responsePromise.catch(() => {
+      });
+      throw invocationError;
+    }
+    try {
+      const response = await responsePromise;
+      return this._mapInvokeResponse(response);
+    } catch (err) {
+      const shouldCancel = err instanceof InvocationError && err.errorDetail == null || invokeOptions.abortSignal?.aborted === true;
+      if (shouldCancel) {
+        await this._sendCancelInvocation(invocationId).catch(() => {
+        });
+      }
+      throw err;
+    } finally {
+      this._invocationManager.discard(invocationId);
+    }
+  }
+  /**
+   * Invoke an upstream event and wait for the correlated response.
+   * @param eventName - The event name
+   * @param content - The payload
+   * @param dataType - The payload type
+   * @param options - Invoke options
+   */
+  async invokeEvent(eventName, content, dataType, options) {
+    return this._operationExecuteWithRetry(() => this._invokeEventAttempt(eventName, content, dataType, options), options?.abortSignal);
+  }
+  /**
+   * Join the client to group
+   * @param groupName - The group name
+   * @param options - The join group options
+   */
+  async joinGroup(groupName, options) {
+    return this._operationExecuteWithRetry(() => this._joinGroupAttempt(groupName, options), options?.abortSignal);
+  }
+  async _joinGroupAttempt(groupName, options) {
+    const group = this._getOrAddGroup(groupName);
+    const result = await this._joinGroupCore(groupName, options);
+    group.isJoined = true;
+    return result;
+  }
+  async _joinGroupCore(groupName, options) {
+    return this._sendMessageWithAckId((id) => {
+      return {
+        group: groupName,
+        ackId: id,
+        kind: "joinGroup"
+      };
+    }, options?.ackId, options?.abortSignal);
+  }
+  /**
+   * Leave the client from group
+   * @param groupName - The group name
+   * @param ackId - The optional ackId. If not specified, client will generate one.
+   * @param abortSignal - The abort signal
+   */
+  async leaveGroup(groupName, options) {
+    return this._operationExecuteWithRetry(() => this._leaveGroupAttempt(groupName, options), options?.abortSignal);
+  }
+  async _leaveGroupAttempt(groupName, options) {
+    const group = this._getOrAddGroup(groupName);
+    const result = await this._sendMessageWithAckId((id) => {
+      return {
+        group: groupName,
+        ackId: id,
+        kind: "leaveGroup"
+      };
+    }, options?.ackId, options?.abortSignal);
+    group.isJoined = false;
+    return result;
+  }
+  /**
+   * Send message to group.
+   * @param groupName - The group name
+   * @param content - The data content
+   * @param dataType - The data type
+   * @param options - The options
+   * @param abortSignal - The abort signal
+   */
+  async sendToGroup(groupName, content, dataType, options) {
+    return this._operationExecuteWithRetry(() => this._sendToGroupAttempt(groupName, content, dataType, options), options?.abortSignal);
+  }
+  async _sendToGroupAttempt(groupName, content, dataType, options) {
+    const fireAndForget = options?.fireAndForget ?? false;
+    const noEcho = options?.noEcho ?? false;
+    if (!fireAndForget) {
+      return this._sendMessageWithAckId((id) => {
+        return {
+          kind: "sendToGroup",
+          group: groupName,
+          dataType,
+          data: content,
+          ackId: id,
+          noEcho
+        };
+      }, options?.ackId, options?.abortSignal);
+    }
+    const message = {
+      kind: "sendToGroup",
+      group: groupName,
+      dataType,
+      data: content,
+      noEcho
+    };
+    await this._sendMessage(message, options?.abortSignal);
+    return { isDuplicated: false };
+  }
+  _getWebSocketClientFactory() {
+    return new WebSocketClientFactory();
+  }
+  async _trySendSequenceAck() {
+    if (!this._protocol.isReliableSubProtocol) {
+      return;
+    }
+    const [isUpdated, seqId] = this._sequenceId.tryGetSequenceId();
+    if (isUpdated && seqId !== null && seqId !== void 0) {
+      const message = {
+        kind: "sequenceAck",
+        sequenceId: seqId
+      };
+      try {
+        await this._sendMessage(message);
+      } catch {
+        this._sequenceId.tryUpdate(seqId);
+      }
+    }
+  }
+  _connectCore(uri) {
+    if (this._isStopping) {
+      throw new Error("Can't start a client during stopping");
+    }
+    return new Promise((resolve, reject) => {
+      const client = this._wsClient = this._getWebSocketClientFactory().create(uri, this._protocol.name);
+      client.onopen(() => {
+        if (this._isStopping) {
+          try {
+            client.close();
+          } catch {
+          }
+          reject(new Error(`The client is stopped`));
+        }
+        logger.verbose("WebSocket connection has opened");
+        this._lastMessageReceived = Date.now();
+        this._changeState(WebPubSubClientState.Connected);
+        if (this._protocol.isReliableSubProtocol) {
+          if (this._sequenceAckTask != null) {
+            this._sequenceAckTask.abort();
+          }
+          this._sequenceAckTask = new AbortableTask(async () => {
+            await this._trySendSequenceAck();
+          }, 1e3);
+        }
+        resolve();
+      });
+      client.onerror((e) => {
+        if (this._sequenceAckTask != null) {
+          this._sequenceAckTask.abort();
+        }
+        reject(e);
+      });
+      client.onclose((code, reason) => {
+        if (this._state === WebPubSubClientState.Connected) {
+          logger.verbose("WebSocket closed after open");
+          if (this._sequenceAckTask != null) {
+            this._sequenceAckTask.abort();
+          }
+          logger.info(`WebSocket connection closed. Code: ${code}, Reason: ${reason}`);
+          this._lastCloseEvent = { code, reason };
+          this._handleConnectionClose.call(this);
+        } else {
+          logger.verbose("WebSocket closed before open");
+          reject(new Error(`Failed to start WebSocket: ${code}`));
+        }
+      });
+      client.onmessage((data) => {
+        const handleAckMessage = (message) => {
+          const isDuplicated = message.error != null && message.error.name === "Duplicate";
+          if (message.success || isDuplicated) {
+            this._ackManager.resolveAck(message.ackId, {
+              ackId: message.ackId,
+              isDuplicated
+            });
+          } else {
+            this._ackManager.rejectAck(message.ackId, new SendMessageError("Failed to send message.", {
+              ackId: message.ackId,
+              errorDetail: message.error
+            }));
+          }
+        };
+        const handleConnectedMessage = async (message) => {
+          this._connectionId = message.connectionId;
+          this._reconnectionToken = message.reconnectionToken;
+          if (!this._isInitialConnected) {
+            this._isInitialConnected = true;
+            if (this._options.autoRejoinGroups) {
+              const groupPromises = [];
+              this._groupMap.forEach((g) => {
+                if (g.isJoined) {
+                  groupPromises.push((async () => {
+                    try {
+                      await this._joinGroupCore(g.name);
+                    } catch (err) {
+                      this._safeEmitRejoinGroupFailed(g.name, err);
+                    }
+                  })());
+                }
+              });
+              await Promise.all(groupPromises).catch(() => {
+              });
+            }
+            this._safeEmitConnected(message.connectionId, message.userId);
+          }
+        };
+        const handleDisconnectedMessage = (message) => {
+          this._lastDisconnectedMessage = message;
+        };
+        const handleGroupDataMessage = (message) => {
+          if (message.sequenceId != null) {
+            const diff = this._sequenceId.tryUpdate(message.sequenceId);
+            if (diff === 0) {
+              return;
+            }
+            if (diff > this._quickSequenceAckDiff) {
+              this._trySendSequenceAck();
+            }
+          }
+          this._safeEmitGroupMessage(message);
+        };
+        const handleServerDataMessage = (message) => {
+          if (message.sequenceId != null) {
+            const diff = this._sequenceId.tryUpdate(message.sequenceId);
+            if (diff === 0) {
+              return;
+            }
+            if (diff > this._quickSequenceAckDiff) {
+              this._trySendSequenceAck();
+            }
+          }
+          this._safeEmitServerMessage(message);
+        };
+        const handleInvokeResponseMessage = (message) => {
+          const resolved = this._invocationManager.resolveInvocation(message);
+          if (!resolved) {
+            logger.verbose(`Received invokeResponse for unknown invocationId: ${message.invocationId}`);
+          }
+        };
+        this._lastMessageReceived = Date.now();
+        let messages;
+        try {
+          let convertedData;
+          if (Array.isArray(data)) {
+            convertedData = Buffer2.concat(data);
+          } else {
+            convertedData = data;
+          }
+          messages = this._protocol.parseMessages(convertedData);
+          if (messages === null) {
+            return;
+          }
+        } catch (err) {
+          logger.warning("An error occurred while parsing the message from service", err);
+          throw err;
+        }
+        if (!Array.isArray(messages)) {
+          messages = [messages];
+        }
+        messages.forEach((message) => {
+          try {
+            switch (message.kind) {
+              case "pong": {
+                break;
+              }
+              case "ack": {
+                handleAckMessage(message);
+                break;
+              }
+              case "connected": {
+                handleConnectedMessage(message);
+                break;
+              }
+              case "disconnected": {
+                handleDisconnectedMessage(message);
+                break;
+              }
+              case "groupData": {
+                handleGroupDataMessage(message);
+                break;
+              }
+              case "serverData": {
+                handleServerDataMessage(message);
+                break;
+              }
+              case "invokeResponse": {
+                handleInvokeResponseMessage(message);
+                break;
+              }
+            }
+          } catch (err) {
+            logger.warning(`An error occurred while handling the message with kind: ${message.kind} from service`, err);
+          }
+        });
+      });
+    });
+  }
+  async _handleConnectionCloseAndNoRecovery() {
+    this._state = WebPubSubClientState.Disconnected;
+    this._safeEmitDisconnected(this._connectionId, this._lastDisconnectedMessage);
+    if (this._options.autoReconnect) {
+      await this._autoReconnect();
+    } else {
+      await this._handleConnectionStopped();
+    }
+  }
+  async _autoReconnect() {
+    let isSuccess = false;
+    let attempt = 0;
+    try {
+      while (!this._isStopping) {
+        try {
+          await this._startFromRestarting();
+          isSuccess = true;
+          break;
+        } catch (err) {
+          logger.warning("An attempt to reconnect connection failed.", err);
+          attempt++;
+          const delayInMs = this._reconnectRetryPolicy.nextRetryDelayInMs(attempt);
+          if (delayInMs == null) {
+            break;
+          }
+          logger.verbose(`Delay time for reconnect attempt ${attempt}: ${delayInMs}`);
+          await delay(delayInMs).catch(() => {
+          });
+        }
+      }
+    } finally {
+      if (!isSuccess) {
+        this._handleConnectionStopped();
+      }
+    }
+  }
+  _handleConnectionStopped() {
+    this._isStopping = false;
+    this._state = WebPubSubClientState.Stopped;
+    this._disposeKeepaliveTasks();
+    this._safeEmitStopped();
+  }
+  async _trySendPing() {
+    if (this._state !== WebPubSubClientState.Connected || !this._wsClient?.isOpen()) {
+      return;
+    }
+    const message = {
+      kind: "ping"
+    };
+    try {
+      await this._sendMessage(message);
+    } catch {
+      logger.warning("Failed to send keepalive message to the service");
+    }
+  }
+  async _checkKeepAliveTimeout() {
+    if (this._state !== WebPubSubClientState.Connected || !this._wsClient?.isOpen()) {
+      return;
+    }
+    const now = Date.now();
+    if (now - this._lastMessageReceived > this._keepAliveTimeoutInMs) {
+      logger.warning(`No messages received for ${now - this._lastMessageReceived} ms. Closing. The keep alive timeout is set to ${this._keepAliveTimeoutInMs} ms.`);
+      this._wsClient?.close();
+    }
+  }
+  _getPingKeepaliveTask() {
+    return new AbortableTask(async () => {
+      await this._trySendPing();
+    }, this._keepAliveIntervalInMs);
+  }
+  _getTimeoutMonitorTask() {
+    const timeout = this._keepAliveTimeoutInMs;
+    const checkInterval = Math.floor(timeout / 3);
+    return new AbortableTask(async () => {
+      await this._checkKeepAliveTimeout();
+    }, checkInterval);
+  }
+  async _sendMessage(message, abortSignal) {
+    if (!this._wsClient || !this._wsClient.isOpen()) {
+      throw new Error("The connection is not connected.");
+    }
+    const payload = this._protocol.writeMessage(message);
+    await this._wsClient.send(payload, abortSignal);
+  }
+  async _sendMessageWithAckId(messageProvider, ackId, abortSignal) {
+    const { ackId: resolvedAckId, wait } = this._ackManager.registerAck(ackId);
+    const message = messageProvider(resolvedAckId);
+    try {
+      await this._sendMessage(message, abortSignal);
+    } catch (error) {
+      this._ackManager.discard(resolvedAckId);
+      let errorMessage = "";
+      if (error instanceof Error) {
+        errorMessage = error.message;
+      }
+      throw new SendMessageError(errorMessage, { ackId: resolvedAckId });
+    }
+    return wait(abortSignal);
+  }
+  async _handleConnectionClose() {
+    this._ackManager.rejectAll((ackId) => {
+      return new SendMessageError("Connection is disconnected before receive ack from the service", {
+        ackId
+      });
+    });
+    this._invocationManager.rejectAll((invocationId) => {
+      return new InvocationError("Connection is disconnected before receiving invoke response from the service", {
+        invocationId
+      });
+    });
+    if (this._isStopping) {
+      logger.warning("The client is stopping state. Stop recovery.");
+      this._handleConnectionCloseAndNoRecovery();
+      return;
+    }
+    if (this._lastCloseEvent && this._lastCloseEvent.code === 1008) {
+      logger.warning("The websocket close with status code 1008. Stop recovery.");
+      this._handleConnectionCloseAndNoRecovery();
+      return;
+    }
+    if (!this._protocol.isReliableSubProtocol) {
+      logger.warning("The protocol is not reliable, recovery is not applicable");
+      this._handleConnectionCloseAndNoRecovery();
+      return;
+    }
+    const recoveryUri = this._buildRecoveryUri();
+    if (!recoveryUri) {
+      logger.warning("Connection id or reconnection token is not available");
+      this._handleConnectionCloseAndNoRecovery();
+      return;
+    }
+    let recovered = false;
+    this._state = WebPubSubClientState.Recovering;
+    const abortSignal = AbortSignal.timeout(30 * 1e3);
+    try {
+      while (!abortSignal.aborted || this._isStopping) {
+        try {
+          await this._connectCore.call(this, recoveryUri);
+          recovered = true;
+          return;
+        } catch {
+          await delay(1e3);
+        }
+      }
+    } finally {
+      if (!recovered) {
+        logger.warning("Recovery attempts failed more then 30 seconds or the client is stopping");
+        this._handleConnectionCloseAndNoRecovery();
+      }
+    }
+  }
+  _safeEmitConnected(connectionId, userId) {
+    this._emitEvent("connected", {
+      connectionId,
+      userId
+    });
+  }
+  _safeEmitDisconnected(connectionId, lastDisconnectedMessage) {
+    this._emitEvent("disconnected", {
+      connectionId,
+      message: lastDisconnectedMessage
+    });
+  }
+  _safeEmitGroupMessage(message) {
+    this._emitEvent("group-message", {
+      message
+    });
+  }
+  _safeEmitServerMessage(message) {
+    this._emitEvent("server-message", {
+      message
+    });
+  }
+  _safeEmitStopped() {
+    this._emitEvent("stopped", {});
+  }
+  _safeEmitRejoinGroupFailed(groupName, err) {
+    this._emitEvent("rejoin-group-failed", {
+      group: groupName,
+      error: err
+    });
+  }
+  _mapInvokeResponse(message) {
+    if (message.success !== true) {
+      if (message.success === false) {
+        throw new InvocationError(message.error?.message ?? "Invocation failed.", {
+          invocationId: message.invocationId,
+          errorDetail: message.error
+        });
+      }
+      throw new InvocationError("Unsupported invoke response frame.", {
+        invocationId: message.invocationId
+      });
+    }
+    return {
+      invocationId: message.invocationId,
+      dataType: message.dataType,
+      data: message.data
+    };
+  }
+  async _sendCancelInvocation(invocationId) {
+    const message = {
+      kind: "cancelInvocation",
+      invocationId
+    };
+    try {
+      await this._sendMessage(message);
+    } catch (err) {
+      logger.verbose(`Failed to send cancelInvocation for ${invocationId}`, err);
+    }
+  }
+  _buildDefaultOptions(clientOptions) {
+    if (clientOptions.autoReconnect == null) {
+      clientOptions.autoReconnect = true;
+    }
+    if (clientOptions.autoRejoinGroups == null) {
+      clientOptions.autoRejoinGroups = true;
+    }
+    if (clientOptions.protocol == null) {
+      clientOptions.protocol = WebPubSubJsonReliableProtocol();
+    }
+    if (clientOptions.keepAliveTimeoutInMs == null) {
+      clientOptions.keepAliveTimeoutInMs = 12e4;
+    }
+    if (clientOptions.keepAliveTimeoutInMs < 0) {
+      throw new RangeError("keepAliveTimeoutInMs must be greater than or equal to 0.");
+    }
+    if (clientOptions.keepAliveIntervalInMs == null) {
+      clientOptions.keepAliveIntervalInMs = 2e4;
+    }
+    if (clientOptions.keepAliveIntervalInMs < 0) {
+      throw new RangeError("keepAliveIntervalInMs must be greater than or equal to 0.");
+    }
+    this._buildMessageRetryOptions(clientOptions);
+    this._buildReconnectRetryOptions(clientOptions);
+    return clientOptions;
+  }
+  _buildMessageRetryOptions(clientOptions) {
+    if (!clientOptions.messageRetryOptions) {
+      clientOptions.messageRetryOptions = {};
+    }
+    if (clientOptions.messageRetryOptions.maxRetries == null || clientOptions.messageRetryOptions.maxRetries < 0) {
+      clientOptions.messageRetryOptions.maxRetries = 3;
+    }
+    if (clientOptions.messageRetryOptions.retryDelayInMs == null || clientOptions.messageRetryOptions.retryDelayInMs < 0) {
+      clientOptions.messageRetryOptions.retryDelayInMs = 1e3;
+    }
+    if (clientOptions.messageRetryOptions.maxRetryDelayInMs == null || clientOptions.messageRetryOptions.maxRetryDelayInMs < 0) {
+      clientOptions.messageRetryOptions.maxRetryDelayInMs = 3e4;
+    }
+    if (clientOptions.messageRetryOptions.mode == null) {
+      clientOptions.messageRetryOptions.mode = "Fixed";
+    }
+  }
+  _buildReconnectRetryOptions(clientOptions) {
+    if (!clientOptions.reconnectRetryOptions) {
+      clientOptions.reconnectRetryOptions = {};
+    }
+    if (clientOptions.reconnectRetryOptions.maxRetries == null || clientOptions.reconnectRetryOptions.maxRetries < 0) {
+      clientOptions.reconnectRetryOptions.maxRetries = Number.MAX_VALUE;
+    }
+    if (clientOptions.reconnectRetryOptions.retryDelayInMs == null || clientOptions.reconnectRetryOptions.retryDelayInMs < 0) {
+      clientOptions.reconnectRetryOptions.retryDelayInMs = 1e3;
+    }
+    if (clientOptions.reconnectRetryOptions.maxRetryDelayInMs == null || clientOptions.reconnectRetryOptions.maxRetryDelayInMs < 0) {
+      clientOptions.reconnectRetryOptions.maxRetryDelayInMs = 3e4;
+    }
+    if (clientOptions.reconnectRetryOptions.mode == null) {
+      clientOptions.reconnectRetryOptions.mode = "Fixed";
+    }
+  }
+  _buildRecoveryUri() {
+    if (this._connectionId && this._reconnectionToken && this._uri) {
+      const url = new URL(this._uri);
+      url.searchParams.append("awps_connection_id", this._connectionId);
+      url.searchParams.append("awps_reconnection_token", this._reconnectionToken);
+      return url.toString();
+    }
+    return null;
+  }
+  _getOrAddGroup(name2) {
+    if (!this._groupMap.has(name2)) {
+      this._groupMap.set(name2, new WebPubSubGroup(name2));
+    }
+    return this._groupMap.get(name2);
+  }
+  _changeState(newState) {
+    logger.verbose(`The client state transfer from ${this._state.toString()} to ${newState.toString()}`);
+    this._state = newState;
+  }
+  async _operationExecuteWithRetry(inner, signal) {
+    let retryAttempt = 0;
+    while (true) {
+      try {
+        return await inner.call(this);
+      } catch (err) {
+        if (err instanceof InvocationError) {
+          throw err;
+        }
+        retryAttempt++;
+        const delayInMs = this._messageRetryPolicy.nextRetryDelayInMs(retryAttempt);
+        if (delayInMs == null) {
+          throw err;
+        }
+        await delay(delayInMs);
+        if (signal?.aborted) {
+          throw err;
+        }
+      }
+    }
+  }
+};
+var RetryPolicy = class {
+  constructor(retryOptions) {
+    __publicField(this, "_retryOptions");
+    __publicField(this, "_maxRetriesToGetMaxDelay");
+    this._retryOptions = retryOptions;
+    this._maxRetriesToGetMaxDelay = Math.ceil(Math.log2(this._retryOptions.maxRetryDelayInMs) - Math.log2(this._retryOptions.retryDelayInMs) + 1);
+  }
+  nextRetryDelayInMs(retryAttempt) {
+    if (retryAttempt > this._retryOptions.maxRetries) {
+      return null;
+    } else {
+      if (this._retryOptions.mode === "Fixed") {
+        return this._retryOptions.retryDelayInMs;
+      } else {
+        return this._calculateExponentialDelay(retryAttempt);
+      }
+    }
+  }
+  _calculateExponentialDelay(attempt) {
+    if (attempt >= this._maxRetriesToGetMaxDelay) {
+      return this._retryOptions.maxRetryDelayInMs;
+    } else {
+      return (1 << attempt - 1) * this._retryOptions.retryDelayInMs;
+    }
+  }
+};
+var WebPubSubGroup = class {
+  constructor(name2) {
+    __publicField(this, "name");
+    __publicField(this, "isJoined", false);
+    this.name = name2;
+  }
+};
+var SequenceId = class {
+  constructor() {
+    __publicField(this, "_sequenceId");
+    __publicField(this, "_isUpdate");
+    this._sequenceId = 0;
+    this._isUpdate = false;
+  }
+  tryUpdate(sequenceId) {
+    this._isUpdate = true;
+    if (sequenceId > this._sequenceId) {
+      const diff = sequenceId - this._sequenceId;
+      this._sequenceId = sequenceId;
+      return diff;
+    }
+    return 0;
+  }
+  tryGetSequenceId() {
+    if (this._isUpdate) {
+      this._isUpdate = false;
+      return [true, this._sequenceId];
+    }
+    return [false, null];
+  }
+  reset() {
+    this._sequenceId = 0;
+    this._isUpdate = false;
+  }
+};
+var AbortableTask = class {
+  constructor(func, interval, obj) {
+    __publicField(this, "_func");
+    __publicField(this, "_abortController");
+    __publicField(this, "_interval");
+    __publicField(this, "_obj");
+    this._func = func;
+    this._abortController = new AbortController();
+    this._interval = interval;
+    this._obj = obj;
+    this._start();
+  }
+  abort() {
+    try {
+      this._abortController.abort();
+    } catch {
+    }
+  }
+  async _start() {
+    const signal = this._abortController.signal;
+    while (!signal.aborted) {
+      try {
+        await this._func(this._obj);
+      } catch {
+      } finally {
+        await delay(this._interval);
+      }
+    }
+  }
+};
+
+// node_modules/tslib/tslib.es6.mjs
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  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]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(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);
+  }
+}
+
+// node_modules/@azure/core-paging/dist/browser/getPagedAsyncIterator.js
+function getPagedAsyncIterator(pagedResult) {
+  var _a;
+  const iter = getItemAsyncIterator(pagedResult);
+  return {
+    next() {
+      return iter.next();
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    byPage: (_a = pagedResult === null || pagedResult === void 0 ? void 0 : pagedResult.byPage) !== null && _a !== void 0 ? _a : ((settings) => {
+      const { continuationToken, maxPageSize } = settings !== null && settings !== void 0 ? settings : {};
+      return getPageAsyncIterator(pagedResult, {
+        pageLink: continuationToken,
+        maxPageSize
+      });
+    })
+  };
+}
+function getItemAsyncIterator(pagedResult) {
+  return __asyncGenerator(this, arguments, function* getItemAsyncIterator_1() {
+    var _a, e_1, _b, _c, _d, e_2, _e, _f;
+    const pages = getPageAsyncIterator(pagedResult);
+    const firstVal = yield __await(pages.next());
+    if (!Array.isArray(firstVal.value)) {
+      const { toElements } = pagedResult;
+      if (toElements) {
+        yield __await(yield* __asyncDelegator(__asyncValues(toElements(firstVal.value))));
+        try {
+          for (var _g = true, pages_1 = __asyncValues(pages), pages_1_1; pages_1_1 = yield __await(pages_1.next()), _a = pages_1_1.done, !_a; _g = true) {
+            _c = pages_1_1.value;
+            _g = false;
+            const page = _c;
+            yield __await(yield* __asyncDelegator(__asyncValues(toElements(page))));
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (!_g && !_a && (_b = pages_1.return)) yield __await(_b.call(pages_1));
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      } else {
+        yield yield __await(firstVal.value);
+        yield __await(yield* __asyncDelegator(__asyncValues(pages)));
+      }
+    } else {
+      yield __await(yield* __asyncDelegator(__asyncValues(firstVal.value)));
+      try {
+        for (var _h = true, pages_2 = __asyncValues(pages), pages_2_1; pages_2_1 = yield __await(pages_2.next()), _d = pages_2_1.done, !_d; _h = true) {
+          _f = pages_2_1.value;
+          _h = false;
+          const page = _f;
+          yield __await(yield* __asyncDelegator(__asyncValues(page)));
+        }
+      } catch (e_2_1) {
+        e_2 = { error: e_2_1 };
+      } finally {
+        try {
+          if (!_h && !_d && (_e = pages_2.return)) yield __await(_e.call(pages_2));
+        } finally {
+          if (e_2) throw e_2.error;
+        }
+      }
+    }
+  });
+}
+function getPageAsyncIterator(pagedResult, options = {}) {
+  return __asyncGenerator(this, arguments, function* getPageAsyncIterator_1() {
+    const { pageLink, maxPageSize } = options;
+    let response = yield __await(pagedResult.getPage(pageLink !== null && pageLink !== void 0 ? pageLink : pagedResult.firstPageLink, maxPageSize));
+    if (!response) {
+      return yield __await(void 0);
+    }
+    yield yield __await(response.page);
+    while (response.nextPageLink) {
+      response = yield __await(pagedResult.getPage(response.nextPageLink, maxPageSize));
+      if (!response) {
+        return yield __await(void 0);
+      }
+      yield yield __await(response.page);
+    }
+  });
+}
+
+// src/constant.ts
+var INVOCATION_NAME = {
+  LOGIN: "chat.login",
+  LIST_USER_CONVERSATION: "chat.listUserConversation",
+  GET_USER_PROPERTIES: "chat.getUserProperties",
+  GET_ROOM: "chat.getRoom",
+  LIST_MESSAGES: "chat.queryMessageHistory",
+  SEND_TEXT_MESSAGE: "chat.sendTextMessage",
+  CREATE_ROOM: "chat.createRoom",
+  JOIN_ROOM: "chat.joinRoom",
+  MANAGE_ROOM_MEMBER: "chat.manageRoomMember"
+};
+var ERRORS = {
+  RoomAlreadyExists: "RoomAlreadyExists",
+  UserAlreadyInRoom: "UserAlreadyInRoom",
+  NoPermissionInRoom: "NoPermissionInRoom",
+  NotStarted: "NotStarted",
+  UnknownRoom: "UnknownRoom",
+  InvalidServerResponse: "InvalidServerResponse"
+};
+
+// src/logger.ts
+var logger2 = createClientLogger("web-pubsub-chat-client:*");
+
+// src/utils.ts
+function isWebPubSubClient(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const anyObj = obj;
+  return typeof anyObj === "object" && (typeof anyObj.start === "function" || typeof anyObj.stop === "function" || typeof anyObj.on === "function");
+}
+
+// src/chatClient.ts
+var ChatError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    /** Stable, machine-readable error code. Compare against {@link KnownChatErrorCode}. */
+    __publicField(this, "code");
+    this.name = "ChatError";
+    this.code = code;
+  }
+};
+var PromiseCompletionSource = class {
+  constructor() {
+    __publicField(this, "promise");
+    __publicField(this, "resolvePromise");
+    this.promise = new Promise((resolve) => {
+      this.resolvePromise = resolve;
+    });
+  }
+  setResult() {
+    this.resolvePromise();
+  }
+  wait() {
+    return this.promise;
+  }
+};
+var ChatClient = class _ChatClient {
+  // Implementation also accepts a pre-built connection (test seam); this is
+  // not a public overload, so it does not appear in the public API surface.
+  constructor(credentialOrConnection) {
+    /** The underlying transport. Private — `ChatClient` builds and owns it. */
+    __publicField(this, "_connection");
+    __publicField(this, "_emitter", new EventEmitter());
+    __publicField(this, "_rooms", /* @__PURE__ */ new Map());
+    __publicField(this, "_conversationIds", /* @__PURE__ */ new Set());
+    __publicField(this, "_userId");
+    __publicField(this, "_isStarted", false);
+    __publicField(this, "_startPromise");
+    // Created after the underlying connection starts so stop() can wait for the single "stopped" event.
+    __publicField(this, "_connectionStoppedTCS");
+    __publicField(this, "_isConnectionStopping", false);
+    this._connection = isWebPubSubClient(credentialOrConnection) ? credentialOrConnection : new WebPubSubClient(credentialOrConnection);
+    this._connection.on("group-message", (e) => {
+      this._handleNotification(e.message.data);
+    });
+    this._connection.on("server-message", (e) => {
+      this._handleNotification(e.message.data);
+    });
+    this._connection.on("stopped", () => {
+      this._connectionStoppedTCS?.setResult();
+      this._connectionStoppedTCS = void 0;
+      this._isConnectionStopping = false;
+      this.resetState();
+    });
+  }
+  async _handleNotification(data) {
+    if (!this._isStarted && !this._startPromise) {
+      return;
+    }
+    logger2.info("Received notification:", data);
+    try {
+      const type = data.notificationType;
+      switch (type) {
+        case "MessageCreated": {
+          const body = data.body;
+          if (!body.conversation.roomId) {
+            logger2.warning(
+              `MessageCreated notification missing roomId; skipping emit. conversationId=${body.conversation.conversationId}`
+            );
+            break;
+          }
+          const event = {
+            roomId: body.conversation.roomId,
+            message: body.message
+          };
+          this._emitter.emit("message", event);
+          break;
+        }
+        case "RoomJoined": {
+          const roomInfo = data.body;
+          this._rooms.set(roomInfo.roomId, roomInfo);
+          const event = { room: roomInfo };
+          this._emitter.emit("room-joined", event);
+          break;
+        }
+        case "RoomMemberJoined": {
+          const body = data.body;
+          const event = { roomId: body.roomId, title: body.title, userId: body.userId };
+          this._emitter.emit("member-joined", event);
+          break;
+        }
+        // someone (not self) left a specific room
+        case "RoomMemberLeft": {
+          const body = data.body;
+          const event = { roomId: body.roomId, title: body.title, userId: body.userId };
+          this._emitter.emit("member-left", event);
+          break;
+        }
+        // self left a specific room
+        case "RoomLeft": {
+          const body = data.body;
+          if (!this._rooms.has(body.roomId)) {
+            break;
+          }
+          const event = { roomId: body.roomId, title: body.title };
+          this._emitter.emit("room-left", event);
+          this._rooms.delete(body.roomId);
+          break;
+        }
+        case "MessageUpdated":
+        case "MessageDeleted":
+        case "RoomClosed":
+        case "AddContact":
+          logger2.warning(`Known notification type ${type} received but not implemented yet.`);
+          break;
+        default:
+          logger2.warning(`Unknown notification type received: ${type}`);
+      }
+    } catch (err) {
+      logger2.error(`Error processing notification, error = ${err}, data: `, data);
+    }
+  }
+  /** Invoke server event and return typed data */
+  async invokeWithReturnType(eventName, payload, dataType, options) {
+    logger2.verbose(`invoke event: '${eventName}', dataType: ${dataType}, payload:`, payload);
+    try {
+      const rawResponse = await this._connection.invokeEvent(eventName, payload, dataType, {
+        abortSignal: options?.abortSignal
+      });
+      logger2.verbose(`invoke response for '${eventName}':`, rawResponse);
+      const data = rawResponse.data;
+      if (data && typeof data === "object" && typeof data.code === "string") {
+        throw new ChatError(`Invocation of event "${eventName}" failed: ${data.code}`, data.code);
+      }
+      return data;
+    } catch (e) {
+      if (e instanceof ChatError) throw e;
+      if (e instanceof InvocationError && e.errorDetail?.name) {
+        throw new ChatError(e.message, e.errorDetail.name);
+      }
+      throw e;
+    }
+  }
+  static async start(clientAccessUrlOrCredential, options) {
+    const credential = typeof clientAccessUrlOrCredential === "string" ? { getClientAccessUrl: async () => clientAccessUrlOrCredential } : clientAccessUrlOrCredential;
+    const chatClient = new _ChatClient(credential);
+    await chatClient.start({ abortSignal: options?.abortSignal });
+    return chatClient;
+  }
+  /**
+   * Connect the underlying transport and authenticate with the chat
+   * service.
+   *
+   * Idempotent: concurrent calls share a single in-flight promise, and
+   * calls made on an already-started client resolve immediately. After
+   * `stop()` the client can be started again; state from the previous
+   * session is reset.
+   *
+   * @param options - Cancellation token for the start operation. Aborting
+   *   leaves the client in its initial (not-started) state.
+   */
+  async start(options) {
+    if (this._startPromise) return this._startPromise;
+    if (this._isStarted) return;
+    if (this._connectionStoppedTCS && this._isConnectionStopping) {
+      await this._connectionStoppedTCS.wait();
+      if (this._startPromise) return this._startPromise;
+      if (this._isStarted) return;
+    }
+    const startPromise = this.startCore(options);
+    this._startPromise = startPromise;
+    try {
+      await startPromise;
+    } finally {
+      if (this._startPromise === startPromise) {
+        this._startPromise = void 0;
+      }
+    }
+  }
+  async startCore(options) {
+    this.resetState();
+    try {
+      await this._connection.start({ abortSignal: options?.abortSignal });
+      this._connectionStoppedTCS = new PromiseCompletionSource();
+      this._isConnectionStopping = false;
+      const loginResponse = await this.invokeWithReturnType(
+        INVOCATION_NAME.LOGIN,
+        "",
+        "text",
+        options
+      );
+      logger2.info("loginResponse", loginResponse);
+      const conversationIds = new Set(loginResponse.conversationIds || []);
+      const roomInfos = await Promise.all(
+        (loginResponse.roomIds || []).map(async (roomId) => {
+          const roomInfo = await this.fetchRoomDetail(roomId, {
+            abortSignal: options?.abortSignal,
+            withMembers: false
+          });
+          return { roomId, roomInfo };
+        })
+      );
+      this._userId = loginResponse.userId;
+      this._conversationIds = conversationIds;
+      roomInfos.forEach(({ roomId, roomInfo }) => {
+        this._rooms.set(roomId, roomInfo);
+      });
+      this._isStarted = true;
+      const startedEvent = { userId: loginResponse.userId };
+      this._emitter.emit("started", startedEvent);
+    } catch (err) {
+      this.resetState();
+      await this.stopConnection();
+      throw err;
+    }
+  }
+  ensureStarted() {
+    if (!this._isStarted) {
+      throw new ChatError("Not started. Please call start() first.", ERRORS.NotStarted);
+    }
+  }
+  /**
+   * Fetch a user's profile.
+   *
+   * @param userId - Id of the user to look up.
+   * @param options - Optional `{ abortSignal }`.
+   */
+  async getUserProfile(userId, options) {
+    this.ensureStarted();
+    return this.invokeWithReturnType(
+      INVOCATION_NAME.GET_USER_PROPERTIES,
+      { userId },
+      "json",
+      options
+    );
+  }
+  async sendToConversation(conversationId, message, options) {
+    this.ensureStarted();
+    const payload = {
+      conversation: { conversationId },
+      content: message
+    };
+    const resp = await this.invokeWithReturnType(
+      INVOCATION_NAME.SEND_TEXT_MESSAGE,
+      payload,
+      "json",
+      options
+    );
+    if (!resp || !resp.id) {
+      throw new ChatError(
+        `Failed to send message to conversation ${conversationId}, got invalid invoke response: ${JSON.stringify(resp)}`,
+        ERRORS.InvalidServerResponse
+      );
+    }
+    const msgId = resp.id;
+    const roomId = Array.from(this._rooms.values()).find((r) => r.defaultConversationId === conversationId)?.roomId;
+    if (!roomId) {
+      logger2.warning(
+        `Failed to find roomId for conversationId ${conversationId} when sending message; skipping local sender-echo emit.`
+      );
+      return { messageId: msgId };
+    }
+    const event = {
+      roomId,
+      message: {
+        messageId: msgId,
+        createdBy: this.userId,
+        messageBodyType: "Inline",
+        content: {
+          text: message,
+          binary: null
+        }
+      }
+    };
+    this._emitter.emit("message", event);
+    return { messageId: msgId };
+  }
+  /**
+   * Send a text message to a room and return the service-assigned message id.
+   *
+   * The room must be one this client has created or joined. The sender also
+   * observes the message through the `"message"` event.
+   *
+   * @param roomId - Target room.
+   * @param message - Message text to send.
+   * @param options - Optional `{ abortSignal }`.
+   * @returns A {@link SendMessageResult} with the service-assigned `messageId`.
+   */
+  async sendToRoom(roomId, message, options) {
+    this.ensureStarted();
+    const conversationId = this._rooms.get(roomId)?.defaultConversationId;
+    if (!conversationId) {
+      throw new ChatError(`Failed to sendToRoom, not found roomId ${roomId}`, ERRORS.UnknownRoom);
+    }
+    return await this.sendToConversation(conversationId, message, options);
+  }
+  // Internal: fetch a room's full wire shape (including its conversation id)
+  // to populate the local cache. Public callers go through getRoomDetail().
+  async fetchRoomDetail(roomId, options) {
+    return this.invokeWithReturnType(
+      INVOCATION_NAME.GET_ROOM,
+      { id: roomId, withMembers: options?.withMembers ?? false },
+      "json",
+      options
+    );
+  }
+  /**
+   * Fetch the detailed view of a room.
+   *
+   * @param roomId - Room to query.
+   * @param options - Optional `{ withMembers, abortSignal }`. Pass
+   *   `withMembers: true` to populate the returned `members` list; it is
+   *   left undefined otherwise.
+   */
+  async getRoomDetail(roomId, options) {
+    this.ensureStarted();
+    return this.fetchRoomDetail(roomId, options);
+  }
+  /**
+   * Create a room and its initial members. The current user is always
+   * included in the resulting member list.
+   *
+   * @param title - Display title for the room.
+   * @param members - Other user ids to invite. The caller is added
+   *   automatically; duplicates are de-duplicated.
+   * @param options - Optional `{ roomId, abortSignal }`. Pass `roomId`
+   *   to choose an id explicitly; omit to let the service assign one.
+   */
+  async createRoom(title, members, options) {
+    this.ensureStarted();
+    let roomDetails = {
+      title,
+      members: [.../* @__PURE__ */ new Set([...members, this.userId])]
+      // deduplicate and add self
+    };
+    if (options?.roomId) {
+      roomDetails = { ...roomDetails, roomId: options.roomId };
+    }
+    const roomInfo = await this.invokeWithReturnType(
+      INVOCATION_NAME.CREATE_ROOM,
+      roomDetails,
+      "json",
+      options
+    );
+    this._rooms.set(roomInfo.roomId, roomInfo);
+    const event = { room: roomInfo };
+    this._emitter.emit("room-joined", event);
+    return roomInfo;
+  }
+  async manageRoomMember(request, options) {
+    await this.invokeWithReturnType(INVOCATION_NAME.MANAGE_ROOM_MEMBER, request, "json", options);
+  }
+  async ensureRoomCached(roomId, options) {
+    if (this._rooms.has(roomId)) {
+      return;
+    }
+    const roomInfo = await this.fetchRoomDetail(roomId, options);
+    this._rooms.set(roomId, roomInfo);
+  }
+  /** Add a user to a room. This is an admin operation where one user adds another user to a room. */
+  async addUserToRoom(roomId, userId, options) {
+    this.ensureStarted();
+    const payload = { roomId, operation: "Add", userId };
+    const isSelf = userId === this.userId;
+    const shouldCacheRoomAfterSelfAdd = isSelf && !this._rooms.has(roomId);
+    try {
+      await this.manageRoomMember(payload, options);
+    } catch (error) {
+      if (!isSelf || !(error instanceof ChatError && error.code === ERRORS.UserAlreadyInRoom)) {
+        throw error;
+      }
+    }
+    if (shouldCacheRoomAfterSelfAdd) {
+      await this.ensureRoomCached(roomId, options);
+    }
+  }
+  /** Remove a user from a room. This is an admin operation where one user removes another user from a room. */
+  async removeUserFromRoom(roomId, userId, options) {
+    this.ensureStarted();
+    const payload = { roomId, operation: "Delete", userId };
+    await this.manageRoomMember(payload, options);
+    if (userId === this.userId) {
+      const roomInfo = this._rooms.get(roomId);
+      if (roomInfo) {
+        this._rooms.delete(roomId);
+        const event = { roomId, title: roomInfo.title };
+        this._emitter.emit("room-left", event);
+      }
+    }
+  }
+  /**
+   * List messages in a room as a paged async iterator.
+   *
+   * The iterator transparently fetches additional pages from the
+   * service as you iterate. For Teams-style infinite scrolling, drive
+   * the iterator one page at a time via `byPage(...)`:
+   *
+   * @example Stream every message (e.g. for export or full sync):
+   * ```ts
+   * for await (const msg of client.listRoomMessages(roomId)) {
+   *   console.log(msg.content.text);
+   * }
+   * ```
+   *
+   * @example Load history one page at a time (Teams-style scroll-back):
+   * ```ts
+   * // Load up to 50 messages per page.
+   * const pages = client.listRoomMessages(roomId).byPage({ maxPageSize: 50 });
+   * const first = await pages.next();
+   * displayMessages(first.value);
+   * // later, when the user scrolls up:
+   * const more = await pages.next();
+   * displayMessages(more.value);
+   * ```
+   *
+   * The room must be one this client has created or joined.
+   */
+  listRoomMessages(roomId, options) {
+    this.ensureStarted();
+    const conversationId = this._rooms.get(roomId)?.defaultConversationId;
+    if (!conversationId) {
+      throw new ChatError(`Failed to listRoomMessages, not found roomId ${roomId}`, ERRORS.UnknownRoom);
+    }
+    const defaultPageSize = options?.maxPageSize ?? 100;
+    const firstPageLink = {
+      conversation: { conversationId },
+      start: options?.startId ?? null,
+      end: options?.endId ?? null,
+      maxCount: defaultPageSize
+    };
+    const fetchPage = async (link, maxPageSize) => {
+      const query = {
+        ...link,
+        maxCount: maxPageSize ?? link.maxCount ?? defaultPageSize
+      };
+      const result = await this.invokeWithReturnType(
+        INVOCATION_NAME.LIST_MESSAGES,
+        query,
+        "json",
+        { abortSignal: options?.abortSignal }
+      );
+      if (result.messages.length === 0) {
+        return void 0;
+      }
+      return { page: result.messages, nextPageLink: result.nextQuery ?? void 0 };
+    };
+    return getPagedAsyncIterator({
+      firstPageLink,
+      getPage: (link, maxPageSize) => fetchPage(link, maxPageSize)
+    });
+  }
+  /** Cached rooms known to the client. */
+  get rooms() {
+    return Array.from(this._rooms.values());
+  }
+  /** Whether the current client has the room in its local joined-room cache. */
+  hasJoinedRoom(roomId) {
+    return this._rooms.has(roomId);
+  }
+  /**
+   * The chat-domain identity of this client, established by `start()`.
+   *
+   * @throws `ChatError` with code `NotStarted` if the client is not started.
+   */
+  get userId() {
+    if (!this._userId) {
+      throw new ChatError("User ID is not set. Please call start() first.", ERRORS.NotStarted);
+    }
+    return this._userId;
+  }
+  on(event, listener) {
+    this._emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this._emitter.off(event, listener);
+  }
+  /**
+   * Stop the underlying connection and reset client state. Idempotent.
+   *
+   * After resolution the client returns to its initial state and may
+   * be started again via `start()`. Callers that want the same identity
+   * should keep their authentication source (URL or credential)
+   * constant.
+   *
+   * Stopping is not cancellable: it tears down the transport and clears
+   * local state, mirroring the underlying `WebPubSubClient.stop()`, which
+   * takes no options.
+   */
+  async stop() {
+    const startPromise = this._startPromise;
+    if (startPromise) {
+      await startPromise.catch(() => void 0);
+    }
+    this._startPromise = void 0;
+    this.resetState();
+    await this.stopConnection();
+  }
+  /**
+   * Reset chat-domain state. Emits `"stopped"` exactly once per
+   * started → not-started transition: if `_isStarted` was already
+   * false on entry (e.g. the pre-start guard inside `startCore()` or
+   * the post-failure rollback), no event fires.
+   */
+  resetState() {
+    const wasStarted = this._isStarted;
+    this._isStarted = false;
+    this._userId = void 0;
+    this._rooms.clear();
+    this._conversationIds.clear();
+    if (wasStarted) {
+      const stoppedEvent = {};
+      this._emitter.emit("stopped", stoppedEvent);
+    }
+  }
+  async stopConnection() {
+    const connectionStoppedTCS = this._connectionStoppedTCS;
+    if (!connectionStoppedTCS) {
+      return;
+    }
+    if (!this._isConnectionStopping) {
+      this._isConnectionStopping = true;
+      try {
+        this._connection.stop();
+      } catch (err) {
+        this._isConnectionStopping = false;
+        throw err;
+      }
+    }
+    await connectionStoppedTCS.wait();
+  }
+};
+
+// src/index.ts
+var KnownChatErrorCode = ERRORS;
+export {
+  ChatClient,
+  ChatError,
+  KnownChatErrorCode
+};
+/*! Bundled license information:
+
+@jspm/core/nodelibs/browser/chunk-DtuTasat.js:
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+*/
+//# sourceMappingURL=index.js.map