werift 0.25.0-alpha.0 → 0.25.1

package/lib/polyfill/index.mjs

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/errors.ts
 function createWebRtcDomException(name, message = name) {
   return new DOMException(message, name);
@@ -822,6 +828,331 @@ function stripZoneId(address) {
   return address.split("%")[0];
 }
 
+// ../common/src/binaryData.ts
+var binaryData_exports = {};
+__export(binaryData_exports, {
+  BinaryReader: () => BinaryReader,
+  BinaryWriter: () => BinaryWriter,
+  NotEnoughDataError: () => NotEnoughDataError,
+  decode: () => decode,
+  encode: () => encode,
+  types: () => types
+});
+var NotEnoughDataError = class extends Error {
+  constructor(expected, received) {
+    super(`requested ${expected} bytes but only ${received} available`);
+    this.name = "NotEnoughDataError";
+  }
+};
+var BinaryReader = class {
+  constructor(buf) {
+    this.buf = buf;
+  }
+  offset = 0;
+  /** The number of unread bytes. */
+  get length() {
+    return this.buf.length - this.offset;
+  }
+  /** The number of bytes consumed so far. */
+  get bytes() {
+    return this.offset;
+  }
+  readBuffer(size) {
+    this.assertSize(size);
+    const res = this.buf.subarray(this.offset, this.offset + size);
+    this.offset += size;
+    return res;
+  }
+  readUIntBE(size) {
+    this.assertSize(size);
+    const res = this.buf.readUIntBE(this.offset, size);
+    this.offset += size;
+    return res;
+  }
+  assertSize(size) {
+    if (size > this.length) {
+      throw new NotEnoughDataError(size, this.length);
+    }
+  }
+};
+var BinaryWriter = class {
+  chunks = [];
+  written = 0;
+  /** The number of bytes written so far. */
+  get bytes() {
+    return this.written;
+  }
+  writeBuffer(buf) {
+    this.chunks.push(buf);
+    this.written += buf.length;
+  }
+  writeUIntBE(value, size) {
+    const buf = Buffer.allocUnsafe(size);
+    switch (size) {
+      case 1:
+        buf.writeUInt8(value, 0);
+        break;
+      case 2:
+        buf.writeUInt16BE(value, 0);
+        break;
+      case 4:
+        buf.writeUInt32BE(value, 0);
+        break;
+      default:
+        buf.writeUIntBE(value, 0, size);
+    }
+    this.writeBuffer(buf);
+  }
+  toBuffer() {
+    return Buffer.concat(this.chunks, this.written);
+  }
+};
+var isObject = (value) => typeof value === "object" && value !== null;
+var isType = (value) => isObject(value) && typeof value.encode === "function" && typeof value.decode === "function";
+var isPlainObject = (value) => {
+  if (!isObject(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var createContext = () => ({
+  node: void 0,
+  current: void 0
+});
+var cloneContext = (context) => ({
+  node: context.node,
+  current: context.current
+});
+var assertSchema = (schema, message) => {
+  if (!isPlainObject(schema)) {
+    throw new TypeError(message);
+  }
+};
+var encodeCommon = (value, typeOrSchema, writer, context) => {
+  if (isType(typeOrSchema)) {
+    typeOrSchema.encode(value, writer, context);
+  } else {
+    encodeSchema(value, typeOrSchema, writer, context);
+  }
+};
+var encodeSchema = (obj, schema, writer, context) => {
+  assertSchema(schema, "Argument `schema` should be a plain object.");
+  if (context.node === void 0) {
+    context.node = obj;
+  }
+  context.current = obj;
+  for (const key of Object.keys(schema)) {
+    const type = schema[key];
+    const value = obj[key];
+    if (isType(type)) {
+      type.encode(value, writer, context);
+    } else {
+      encodeSchema(value, type, writer, context);
+      context.current = obj;
+    }
+  }
+};
+var decodeCommon = (reader, typeOrSchema, context) => {
+  if (isType(typeOrSchema)) {
+    return typeOrSchema.decode(reader, context);
+  }
+  return decodeSchema(reader, typeOrSchema, context);
+};
+var decodeSchema = (reader, schema, context) => {
+  assertSchema(schema, "Argument #2 should be a plain object.");
+  const node = /* @__PURE__ */ Object.create(null);
+  if (context.node === void 0) {
+    context.node = node;
+  }
+  context.current = node;
+  for (const key of Object.keys(schema)) {
+    const type = schema[key];
+    if (isType(type)) {
+      node[key] = type.decode(reader, context);
+    } else {
+      node[key] = decodeSchema(reader, type, context);
+      context.current = node;
+    }
+  }
+  return node;
+};
+function encode(obj, typeOrSchema) {
+  const writer = new BinaryWriter();
+  encodeCommon(obj, typeOrSchema, writer, createContext());
+  return writer.toBuffer();
+}
+function decode(buf, typeOrSchema) {
+  return decodeCommon(new BinaryReader(buf), typeOrSchema, createContext());
+}
+var createUIntBE = (size) => ({
+  encode: (value, writer) => writer.writeUIntBE(value, size),
+  decode: (reader) => reader.readUIntBE(size)
+});
+var assertLengthSpec = (length) => {
+  if (typeof length !== "number" && !isType(length) && typeof length !== "function") {
+    throw new TypeError("Unknown type of argument #1.");
+  }
+};
+var checkLength = (required, having, name) => {
+  if (required !== having) {
+    throw new Error(`${name} required length ${required} instead of ${having}`);
+  }
+};
+var checkLengthType = (length, message) => {
+  if (typeof length !== "number") {
+    throw new TypeError(message);
+  }
+};
+function buffer(length) {
+  assertLengthSpec(length);
+  const lengthTypeError = "Length of a buffer should be a number.";
+  return {
+    encode(buf, writer, context) {
+      if (!Buffer.isBuffer(buf)) {
+        throw new TypeError("Argument 1 should be a Buffer or a BinaryStream.");
+      }
+      if (typeof length === "number") {
+        checkLength(length, buf.length, "Buffer");
+      } else if (isType(length)) {
+        length.encode(buf.length, writer, context);
+      } else {
+        const expected = length(context);
+        checkLengthType(expected, lengthTypeError);
+        checkLength(expected, buf.length, "Buffer");
+      }
+      writer.writeBuffer(buf);
+    },
+    decode(reader, context) {
+      let size;
+      if (typeof length === "number") {
+        size = length;
+      } else if (isType(length)) {
+        size = length.decode(reader, context);
+      } else {
+        size = length(context);
+      }
+      checkLengthType(size, lengthTypeError);
+      return reader.readBuffer(size);
+    }
+  };
+}
+function array(type, length, lengthType = "count") {
+  if (!isType(type) && !isPlainObject(type)) {
+    throw new TypeError("Argument #1 should be a valid type.");
+  }
+  assertLengthSpec(length);
+  const isLengthInBytes = lengthType === "bytes";
+  const sizeTypeError = "Length of an array should be a number.";
+  return {
+    encode(items, writer, parent) {
+      if (!Array.isArray(items)) {
+        throw new TypeError("Argument #1 should be an Array.");
+      }
+      const context = cloneContext(parent);
+      let expectedSize = 0;
+      if (typeof length === "number") {
+        expectedSize = length;
+      } else if (isType(length)) {
+        expectedSize = items.length;
+      } else {
+        expectedSize = length(context);
+        checkLengthType(expectedSize, sizeTypeError);
+      }
+      const body = new BinaryWriter();
+      for (const item of items) {
+        encodeCommon(item, type, body, context);
+      }
+      if (isLengthInBytes) {
+        if (isType(length)) {
+          expectedSize = body.bytes;
+        }
+        checkLength(body.bytes, expectedSize, "Argument #1");
+      } else {
+        checkLength(expectedSize, items.length, "Argument #1");
+      }
+      if (isType(length)) {
+        length.encode(expectedSize, writer, context);
+      }
+      writer.writeBuffer(body.toBuffer());
+    },
+    decode(reader, parent) {
+      const context = cloneContext(parent);
+      let expectedSize;
+      if (typeof length === "number") {
+        expectedSize = length;
+      } else if (isType(length)) {
+        expectedSize = length.decode(reader, context);
+      } else {
+        expectedSize = length(context);
+      }
+      checkLengthType(expectedSize, sizeTypeError);
+      const items = [];
+      if (isLengthInBytes) {
+        const before = reader.bytes;
+        let bytes2 = 0;
+        while (bytes2 < expectedSize) {
+          items.push(decodeCommon(reader, type, context));
+          bytes2 = reader.bytes - before;
+        }
+        if (bytes2 > expectedSize) {
+          throw new Error("Incorrect length of an array.");
+        }
+      } else {
+        for (let i = 0; i < expectedSize; i++) {
+          items.push(decodeCommon(reader, type, context));
+        }
+      }
+      return items;
+    }
+  };
+}
+function string(length, encoding = "ascii") {
+  if (!Buffer.isEncoding(encoding)) {
+    throw new Error("Argument #2 should be an encoding name.");
+  }
+  assertLengthSpec(length);
+  const lengthTypeError = "Length of a buffer should be a number.";
+  return {
+    encode(value, writer, context) {
+      const buf = Buffer.from(value.toString(), encoding);
+      if (typeof length === "number") {
+        if (buf.length !== length) {
+          throw new Error(`Size of string should be ${length} in bytes.`);
+        }
+      } else if (isType(length)) {
+        length.encode(buf.length, writer, context);
+      } else {
+        const expected = length(context);
+        checkLengthType(expected, lengthTypeError);
+        checkLength(expected, buf.length, "Buffer");
+      }
+      writer.writeBuffer(buf);
+    },
+    decode(reader, context) {
+      let size;
+      if (typeof length === "number") {
+        size = length;
+      } else if (isType(length)) {
+        size = length.decode(reader, context);
+        checkLengthType(size, "Size of a string should be a number.");
+      } else {
+        size = length(context);
+        checkLengthType(size, lengthTypeError);
+      }
+      return reader.readBuffer(size).toString(encoding);
+    }
+  };
+}
+var types = {
+  uint8: createUIntBE(1),
+  uint16be: createUIntBE(2),
+  uint24be: createUIntBE(3),
+  uint32be: createUIntBE(4),
+  uint48be: createUIntBE(6),
+  buffer,
+  array,
+  string
+};
+
 // src/helper.ts
 import { EventEmitter } from "node:events";
 function enumerate(arr) {
@@ -1148,7 +1479,6 @@ import { isIPv4 as isIPv44 } from "net";
 import { createSign, randomBytes as randomBytes2, webcrypto } from "crypto";
 import { Certificate, PrivateKey } from "@fidm/x509";
 import * as x509 from "@peculiar/x509";
-import { encode, types } from "@shinyoshiaki/binary-data";
 
 // ../dtls/src/cipher/const.ts
 var SignatureAlgorithm = {
@@ -1188,7 +1518,6 @@ var signatures = [
 
 // ../dtls/src/cipher/prf.ts
 import { createHash, createHmac } from "crypto";
-import { createDecode } from "@shinyoshiaki/binary-data";
 import nacl from "tweetnacl";
 
 // ../dtls/src/cipher/ec.ts
@@ -1290,7 +1619,7 @@ function prfEncryptionKeys(masterSecret, clientRandom, serverRandom, prfKeyLen,
     size,
     algorithm
   );
-  const stream = createDecode(keyBlock);
+  const stream = new binaryData_exports.BinaryReader(keyBlock);
   const clientWriteKey = stream.readBuffer(prfKeyLen);
   const serverWriteKey = stream.readBuffer(prfKeyLen);
   const clientNonceImplicit = stream.readBuffer(prfIvLen);
@@ -1344,6 +1673,7 @@ var AbstractCipher = class {
 };
 
 // ../dtls/src/context/cipher.ts
+var { encode: encode2, types: types2 } = binaryData_exports;
 var crypto = webcrypto;
 x509.cryptoProvider.set(crypto);
 var CipherContext = class {
@@ -1489,15 +1819,13 @@ var CipherContext = class {
     this.signatureHashAlgorithm = signatureHash;
   }
   valueKeySignature(clientRandom, serverRandom, publicKey, namedCurve) {
-    const serverParams = Buffer.from(
-      encode(
-        {
-          type: CurveType.named_curve_3,
-          curve: namedCurve,
-          len: publicKey.length
-        },
-        { type: types.uint8, curve: types.uint16be, len: types.uint8 }
-      ).slice()
+    const serverParams = encode2(
+      {
+        type: CurveType.named_curve_3,
+        curve: namedCurve,
+        len: publicKey.length
+      },
+      { type: types2.uint8, curve: types2.uint16be, len: types2.uint8 }
     );
     return Buffer.concat([clientRandom, serverRandom, serverParams, publicKey]);
   }
@@ -1513,12 +1841,6 @@ var SrtpContext = class {
   }
 };
 
-// ../dtls/src/handshake/message/client/hello.ts
-import { decode as decode3, encode as encode4, types as types5 } from "@shinyoshiaki/binary-data";
-
-// ../dtls/src/record/message/fragment.ts
-import { decode, encode as encode2, types as types2 } from "@shinyoshiaki/binary-data";
-
 // ../dtls/src/helper.ts
 var dumpBuffer = (data) => "0x" + data.toString("hex").replace(/(.)(.)/g, "$1$2 ").split(" ").filter((s) => s != void 0 && s.length > 0).join(",0x");
 var getObjectSummary = (obj) => Object.entries({ ...obj }).reduce((acc, [key, value]) => {
@@ -1532,6 +1854,7 @@ var getObjectSummary = (obj) => Object.entries({ ...obj }).reduce((acc, [key, va
 }, {});
 
 // ../dtls/src/record/message/fragment.ts
+var { decode: decode2, encode: encode3, types: types3 } = binaryData_exports;
 var FragmentedHandshake = class _FragmentedHandshake {
   constructor(msg_type, length, message_seq, fragment_offset, fragment_length, fragment) {
     this.msg_type = msg_type;
@@ -1542,12 +1865,12 @@ var FragmentedHandshake = class _FragmentedHandshake {
     this.fragment = fragment;
   }
   static spec = {
-    msg_type: types2.uint8,
-    length: types2.uint24be,
-    message_seq: types2.uint16be,
-    fragment_offset: types2.uint24be,
-    fragment_length: types2.uint24be,
-    fragment: types2.buffer((context) => context.current.fragment_length)
+    msg_type: types3.uint8,
+    length: types3.uint24be,
+    message_seq: types3.uint16be,
+    fragment_offset: types3.uint24be,
+    fragment_length: types3.uint24be,
+    fragment: types3.buffer((context) => context.current.fragment_length)
   };
   get summary() {
     return getObjectSummary(this);
@@ -1564,12 +1887,11 @@ var FragmentedHandshake = class _FragmentedHandshake {
   }
   static deSerialize(buf) {
     return new _FragmentedHandshake(
-      ...Object.values(decode(buf, _FragmentedHandshake.spec))
+      ...Object.values(decode2(buf, _FragmentedHandshake.spec))
     );
   }
   serialize() {
-    const res = encode2(this, _FragmentedHandshake.spec).slice();
-    return Buffer.from(res);
+    return encode3(this, _FragmentedHandshake.spec);
   }
   chunk(maxFragmentLength) {
     let start = 0;
@@ -1642,46 +1964,46 @@ var FragmentedHandshake = class _FragmentedHandshake {
 };
 
 // ../dtls/src/handshake/binary.ts
-import { types as types3 } from "@shinyoshiaki/binary-data";
-var { uint16be, uint24be, buffer, array, uint8, string } = types3;
+var { types: types4 } = binaryData_exports;
+var { uint16be, uint24be, buffer: buffer2, array: array2, uint8, string: string2 } = types4;
 var Extension = {
   type: uint16be,
-  data: buffer(uint16be)
+  data: buffer2(uint16be)
 };
-var ExtensionList = array(Extension, uint16be, "bytes");
-var ASN11Cert = buffer(uint24be);
+var ExtensionList = array2(Extension, uint16be, "bytes");
+var ASN11Cert = buffer2(uint24be);
 var ClientCertificateType = uint8;
-var DistinguishedName = string(uint16be);
+var DistinguishedName = string2(uint16be);
 var SignatureHashAlgorithm = { hash: uint8, signature: uint8 };
 var ProtocolVersion = { major: uint8, minor: uint8 };
 
 // ../dtls/src/handshake/random.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { decode as decode2, encode as encode3, types as types4 } from "@shinyoshiaki/binary-data";
+var { decode: decode3, encode: encode4, types: types5 } = binaryData_exports;
 var DtlsRandom = class _DtlsRandom {
   constructor(gmt_unix_time = Math.floor(Date.now() / 1e3), random_bytes = randomBytes3(28)) {
     this.gmt_unix_time = gmt_unix_time;
     this.random_bytes = random_bytes;
   }
   static spec = {
-    gmt_unix_time: types4.uint32be,
-    random_bytes: types4.buffer(28)
+    gmt_unix_time: types5.uint32be,
+    random_bytes: types5.buffer(28)
   };
   static deSerialize(buf) {
     return new _DtlsRandom(
-      ...Object.values(decode2(buf, _DtlsRandom.spec))
+      ...Object.values(decode3(buf, _DtlsRandom.spec))
     );
   }
   static from(spec) {
     return new _DtlsRandom(...Object.values(spec));
   }
   serialize() {
-    const res = encode3(this, _DtlsRandom.spec).slice();
-    return Buffer.from(res);
+    return encode4(this, _DtlsRandom.spec);
   }
 };
 
 // ../dtls/src/handshake/message/client/hello.ts
+var { decode: decode4, encode: encode5, types: types6 } = binaryData_exports;
 var ClientHello = class _ClientHello {
   constructor(clientVersion, random, sessionId, cookie, cipherSuites2, compressionMethods, extensions) {
     this.clientVersion = clientVersion;
@@ -1695,12 +2017,12 @@ var ClientHello = class _ClientHello {
   msgType = 1 /* client_hello_1 */;
   messageSeq = 0;
   static spec = {
-    clientVersion: { major: types5.uint8, minor: types5.uint8 },
+    clientVersion: { major: types6.uint8, minor: types6.uint8 },
     random: DtlsRandom.spec,
-    sessionId: types5.buffer(types5.uint8),
-    cookie: types5.buffer(types5.uint8),
-    cipherSuites: types5.array(types5.uint16be, types5.uint16be, "bytes"),
-    compressionMethods: types5.array(types5.uint8, types5.uint8, "bytes"),
+    sessionId: types6.buffer(types6.uint8),
+    cookie: types6.buffer(types6.uint8),
+    cipherSuites: types6.array(types6.uint16be, types6.uint16be, "bytes"),
+    compressionMethods: types6.array(types6.uint8, types6.uint8, "bytes"),
     extensions: ExtensionList
   };
   static createEmpty() {
@@ -1716,12 +2038,11 @@ var ClientHello = class _ClientHello {
   }
   static deSerialize(buf) {
     return new _ClientHello(
-      ...Object.values(decode3(buf, _ClientHello.spec))
+      ...Object.values(decode4(buf, _ClientHello.spec))
     );
   }
   serialize() {
-    const res = encode4(this, _ClientHello.spec).slice();
-    return Buffer.from(res);
+    return encode5(this, _ClientHello.spec);
   }
   toFragment() {
     const body = this.serialize();
@@ -1740,7 +2061,7 @@ var ClientHello = class _ClientHello {
 import { setTimeout as setTimeout2 } from "timers/promises";
 
 // ../dtls/src/record/message/header.ts
-import { decode as decode4, encode as encode5, types as types6 } from "@shinyoshiaki/binary-data";
+var { decode: decode5, encode: encode6, types: types7 } = binaryData_exports;
 var MACHeader = class _MACHeader {
   constructor(epoch, sequenceNumber, contentType, protocolVersion, contentLen) {
     this.epoch = epoch;
@@ -1750,11 +2071,11 @@ var MACHeader = class _MACHeader {
     this.contentLen = contentLen;
   }
   static spec = {
-    epoch: types6.uint16be,
-    sequenceNumber: types6.uint48be,
-    contentType: types6.uint8,
+    epoch: types7.uint16be,
+    sequenceNumber: types7.uint48be,
+    contentType: types7.uint8,
     protocolVersion: ProtocolVersion,
-    contentLen: types6.uint16be
+    contentLen: types7.uint16be
   };
   static createEmpty() {
     return new _MACHeader(
@@ -1767,12 +2088,11 @@ var MACHeader = class _MACHeader {
   }
   static deSerialize(buf) {
     return new _MACHeader(
-      ...Object.values(decode4(buf, _MACHeader.spec))
+      ...Object.values(decode5(buf, _MACHeader.spec))
     );
   }
   serialize() {
-    const res = encode5(this, _MACHeader.spec).slice();
-    return Buffer.from(res);
+    return encode6(this, _MACHeader.spec);
   }
 };
 
@@ -1820,15 +2140,15 @@ var DtlsPlaintext = class _DtlsPlaintext {
   serialize() {
     const fragmentLength = this.fragment.length;
     const totalLength = 13 + fragmentLength;
-    const buffer2 = Buffer.alloc(totalLength);
-    buffer2.writeUInt8(this.recordLayerHeader.contentType, 0);
-    buffer2.writeUInt8(this.recordLayerHeader.protocolVersion.major, 1);
-    buffer2.writeUInt8(this.recordLayerHeader.protocolVersion.minor, 2);
-    buffer2.writeUInt16BE(this.recordLayerHeader.epoch, 3);
-    buffer2.writeUIntBE(this.recordLayerHeader.sequenceNumber, 5, 6);
-    buffer2.writeUInt16BE(fragmentLength, 11);
-    this.fragment.copy(buffer2, 13);
-    return buffer2;
+    const buffer3 = Buffer.alloc(totalLength);
+    buffer3.writeUInt8(this.recordLayerHeader.contentType, 0);
+    buffer3.writeUInt8(this.recordLayerHeader.protocolVersion.major, 1);
+    buffer3.writeUInt8(this.recordLayerHeader.protocolVersion.minor, 2);
+    buffer3.writeUInt16BE(this.recordLayerHeader.epoch, 3);
+    buffer3.writeUIntBE(this.recordLayerHeader.sequenceNumber, 5, 6);
+    buffer3.writeUInt16BE(fragmentLength, 11);
+    this.fragment.copy(buffer3, 13);
+    return buffer3;
   }
   computeMACHeader() {
     return new MACHeader(
@@ -2386,12 +2706,12 @@ var ExtendedMasterSecret = class {
 };
 
 // ../dtls/src/handshake/extensions/renegotiationIndication.ts
-import { decode as decode5, encode as encode6, types as types7 } from "@shinyoshiaki/binary-data";
+var { decode: decode6, encode: encode7, types: types8 } = binaryData_exports;
 var RenegotiationIndication = class _RenegotiationIndication {
   static type = 65281;
   static spec = {
-    type: types7.uint16be,
-    data: types7.uint8
+    type: types8.uint16be,
+    data: types8.uint8
   };
   type = _RenegotiationIndication.type;
   data = 0;
@@ -2404,12 +2724,11 @@ var RenegotiationIndication = class _RenegotiationIndication {
   }
   static deSerialize(buf) {
     return new _RenegotiationIndication(
-      decode5(buf, _RenegotiationIndication.spec)
+      decode6(buf, _RenegotiationIndication.spec)
     );
   }
   serialize() {
-    const res = encode6(this, _RenegotiationIndication.spec).slice();
-    return Buffer.from(res);
+    return encode7(this, _RenegotiationIndication.spec);
   }
   get extension() {
     return {
@@ -2420,13 +2739,13 @@ var RenegotiationIndication = class _RenegotiationIndication {
 };
 
 // ../dtls/src/handshake/extensions/useSrtp.ts
-import { decode as decode6, encode as encode7, types as types8 } from "@shinyoshiaki/binary-data";
+var { decode: decode7, encode: encode8, types: types9 } = binaryData_exports;
 var UseSRTP = class _UseSRTP {
   static type = 14;
   // 9.  IANA Considerations
   static spec = {
-    type: types8.uint16be,
-    data: types8.buffer(types8.uint16be)
+    type: types9.uint16be,
+    data: types9.buffer(types9.uint16be)
   };
   type = _UseSRTP.type;
   data = Buffer.from([]);
@@ -2443,7 +2762,7 @@ var UseSRTP = class _UseSRTP {
     return v;
   }
   static deSerialize(buf) {
-    const useSrtp = new _UseSRTP(decode6(buf, _UseSRTP.spec));
+    const useSrtp = new _UseSRTP(decode7(buf, _UseSRTP.spec));
     const profileLength = useSrtp.data.readUInt16BE();
     const profiles = new Array(profileLength / 2);
     for (let i = 0; i < profiles.length; i++) {
@@ -2466,8 +2785,7 @@ var UseSRTP = class _UseSRTP {
       this.mki
     ]);
     this.data = data;
-    const res = encode7(this, _UseSRTP.spec).slice();
-    return Buffer.from(res);
+    return encode8(this, _UseSRTP.spec);
   }
   static fromData(buf) {
     const head = Buffer.alloc(4);
@@ -2484,7 +2802,7 @@ var UseSRTP = class _UseSRTP {
 };
 
 // ../dtls/src/handshake/message/certificate.ts
-import { decode as decode7, encode as encode8, types as types9 } from "@shinyoshiaki/binary-data";
+var { decode: decode8, encode: encode9, types: types10 } = binaryData_exports;
 var Certificate2 = class _Certificate {
   constructor(certificateList) {
     this.certificateList = certificateList;
@@ -2492,19 +2810,18 @@ var Certificate2 = class _Certificate {
   msgType = 11 /* certificate_11 */;
   messageSeq;
   static spec = {
-    certificateList: types9.array(ASN11Cert, types9.uint24be, "bytes")
+    certificateList: types10.array(ASN11Cert, types10.uint24be, "bytes")
   };
   static createEmpty() {
     return new _Certificate(void 0);
   }
   static deSerialize(buf) {
     return new _Certificate(
-      ...Object.values(decode7(buf, _Certificate.spec))
+      ...Object.values(decode8(buf, _Certificate.spec))
     );
   }
   serialize() {
-    const res = encode8(this, _Certificate.spec).slice();
-    return Buffer.from(res);
+    return encode9(this, _Certificate.spec);
   }
   toFragment() {
     const body = this.serialize();
@@ -2520,30 +2837,29 @@ var Certificate2 = class _Certificate {
 };
 
 // ../dtls/src/handshake/message/changeCipherSpec.ts
-import { decode as decode8, encode as encode9, types as types10 } from "@shinyoshiaki/binary-data";
+var { decode: decode9, encode: encode10, types: types11 } = binaryData_exports;
 var ChangeCipherSpec = class _ChangeCipherSpec {
   constructor(type = 1) {
     this.type = type;
   }
   static spec = {
-    type: types10.uint8
+    type: types11.uint8
   };
   static createEmpty() {
     return new _ChangeCipherSpec();
   }
   static deSerialize(buf) {
     return new _ChangeCipherSpec(
-      ...Object.values(decode8(buf, _ChangeCipherSpec.spec))
+      ...Object.values(decode9(buf, _ChangeCipherSpec.spec))
     );
   }
   serialize() {
-    const res = encode9(this, _ChangeCipherSpec.spec).slice();
-    return Buffer.from(res);
+    return encode10(this, _ChangeCipherSpec.spec);
   }
 };
 
 // ../dtls/src/handshake/message/client/certificateVerify.ts
-import { decode as decode9, encode as encode10, types as types11 } from "@shinyoshiaki/binary-data";
+var { decode: decode10, encode: encode11, types: types12 } = binaryData_exports;
 var CertificateVerify = class _CertificateVerify {
   constructor(algorithm, signature) {
     this.algorithm = algorithm;
@@ -2552,21 +2868,20 @@ var CertificateVerify = class _CertificateVerify {
   msgType = 15 /* certificate_verify_15 */;
   messageSeq;
   static spec = {
-    algorithm: types11.uint16be,
-    signature: types11.buffer(types11.uint16be)
+    algorithm: types12.uint16be,
+    signature: types12.buffer(types12.uint16be)
   };
   static createEmpty() {
     return new _CertificateVerify(void 0, void 0);
   }
   static deSerialize(buf) {
-    const res = decode9(buf, _CertificateVerify.spec);
+    const res = decode10(buf, _CertificateVerify.spec);
     return new _CertificateVerify(
       ...Object.values(res)
     );
   }
   serialize() {
-    const res = encode10(this, _CertificateVerify.spec).slice();
-    return Buffer.from(res);
+    return encode11(this, _CertificateVerify.spec);
   }
   toFragment() {
     const body = this.serialize();
@@ -2582,7 +2897,7 @@ var CertificateVerify = class _CertificateVerify {
 };
 
 // ../dtls/src/handshake/message/client/keyExchange.ts
-import { decode as decode10, encode as encode11, types as types12 } from "@shinyoshiaki/binary-data";
+var { decode: decode11, encode: encode12, types: types13 } = binaryData_exports;
 var ClientKeyExchange = class _ClientKeyExchange {
   constructor(publicKey) {
     this.publicKey = publicKey;
@@ -2590,20 +2905,19 @@ var ClientKeyExchange = class _ClientKeyExchange {
   msgType = 16 /* client_key_exchange_16 */;
   messageSeq;
   static spec = {
-    publicKey: types12.buffer(types12.uint8)
+    publicKey: types13.buffer(types13.uint8)
   };
   static createEmpty() {
     return new _ClientKeyExchange(void 0);
   }
   static deSerialize(buf) {
-    const res = decode10(buf, _ClientKeyExchange.spec);
+    const res = decode11(buf, _ClientKeyExchange.spec);
     return new _ClientKeyExchange(
       ...Object.values(res)
     );
   }
   serialize() {
-    const res = encode11(this, _ClientKeyExchange.spec).slice();
-    return Buffer.from(res);
+    return encode12(this, _ClientKeyExchange.spec);
   }
   toFragment() {
     const body = this.serialize();
@@ -2648,7 +2962,7 @@ var Finished = class _Finished {
 };
 
 // ../dtls/src/handshake/message/server/certificateRequest.ts
-import { decode as decode11, encode as encode12, types as types13 } from "@shinyoshiaki/binary-data";
+var { decode: decode12, encode: encode13, types: types14 } = binaryData_exports;
 var ServerCertificateRequest = class _ServerCertificateRequest {
   constructor(certificateTypes2, signatures2, authorities) {
     this.certificateTypes = certificateTypes2;
@@ -2658,9 +2972,9 @@ var ServerCertificateRequest = class _ServerCertificateRequest {
   msgType = 13 /* certificate_request_13 */;
   messageSeq;
   static spec = {
-    certificateTypes: types13.array(ClientCertificateType, types13.uint8, "bytes"),
-    signatures: types13.array(SignatureHashAlgorithm, types13.uint16be, "bytes"),
-    authorities: types13.array(DistinguishedName, types13.uint16be, "bytes")
+    certificateTypes: types14.array(ClientCertificateType, types14.uint8, "bytes"),
+    signatures: types14.array(SignatureHashAlgorithm, types14.uint16be, "bytes"),
+    authorities: types14.array(DistinguishedName, types14.uint16be, "bytes")
   };
   static createEmpty() {
     return new _ServerCertificateRequest(
@@ -2671,12 +2985,11 @@ var ServerCertificateRequest = class _ServerCertificateRequest {
   }
   static deSerialize(buf) {
     return new _ServerCertificateRequest(
-      ...Object.values(decode11(buf, _ServerCertificateRequest.spec))
+      ...Object.values(decode12(buf, _ServerCertificateRequest.spec))
     );
   }
   serialize() {
-    const res = encode12(this, _ServerCertificateRequest.spec).slice();
-    return Buffer.from(res);
+    return encode13(this, _ServerCertificateRequest.spec);
   }
   toFragment() {
     const body = this.serialize();
@@ -2692,7 +3005,7 @@ var ServerCertificateRequest = class _ServerCertificateRequest {
 };
 
 // ../dtls/src/handshake/message/server/hello.ts
-import { decode as decode12, encode as encode13, types as types14 } from "@shinyoshiaki/binary-data";
+var { decode: decode13, encode: encode14, types: types15 } = binaryData_exports;
 var ServerHello = class _ServerHello {
   constructor(serverVersion, random, sessionId, cipherSuite, compressionMethod, extensions) {
     this.serverVersion = serverVersion;
@@ -2707,9 +3020,9 @@ var ServerHello = class _ServerHello {
   static spec = {
     serverVersion: ProtocolVersion,
     random: DtlsRandom.spec,
-    sessionId: types14.buffer(types14.uint8),
-    cipherSuite: types14.uint16be,
-    compressionMethod: types14.uint8
+    sessionId: types15.buffer(types15.uint8),
+    cipherSuite: types15.uint16be,
+    compressionMethod: types15.uint8
   };
   static createEmpty() {
     return new _ServerHello(
@@ -2722,7 +3035,7 @@ var ServerHello = class _ServerHello {
     );
   }
   static deSerialize(buf) {
-    const res = decode12(buf, _ServerHello.spec);
+    const res = decode13(buf, _ServerHello.spec);
     const cls = new _ServerHello(
       ...Object.values(res)
     );
@@ -2730,18 +3043,17 @@ var ServerHello = class _ServerHello {
     if (expect.length < buf.length) {
       return new _ServerHello(
         ...Object.values(
-          decode12(buf, { ..._ServerHello.spec, extensions: ExtensionList })
+          decode13(buf, { ..._ServerHello.spec, extensions: ExtensionList })
         )
       );
     }
     return cls;
   }
   serialize() {
-    const res = this.extensions === void 0 ? encode13(this, _ServerHello.spec).slice() : encode13(this, {
+    return this.extensions === void 0 ? encode14(this, _ServerHello.spec) : encode14(this, {
       ..._ServerHello.spec,
       extensions: ExtensionList
-    }).slice();
-    return Buffer.from(res);
+    });
   }
   toFragment() {
     const body = this.serialize();
@@ -2757,7 +3069,7 @@ var ServerHello = class _ServerHello {
 };
 
 // ../dtls/src/handshake/message/server/helloDone.ts
-import { decode as decode13, encode as encode14 } from "@shinyoshiaki/binary-data";
+var { decode: decode14, encode: encode15 } = binaryData_exports;
 var ServerHelloDone = class _ServerHelloDone {
   msgType = 14 /* server_hello_done_14 */;
   messageSeq;
@@ -2767,12 +3079,11 @@ var ServerHelloDone = class _ServerHelloDone {
   }
   static deSerialize(buf) {
     return new _ServerHelloDone(
-      ...Object.values(decode13(buf, _ServerHelloDone.spec))
+      ...Object.values(decode14(buf, _ServerHelloDone.spec))
     );
   }
   serialize() {
-    const res = encode14(this, _ServerHelloDone.spec).slice();
-    return Buffer.from(res);
+    return encode15(this, _ServerHelloDone.spec);
   }
   toFragment() {
     const body = this.serialize();
@@ -2787,16 +3098,14 @@ var ServerHelloDone = class _ServerHelloDone {
   }
 };
 
-// ../dtls/src/handshake/message/server/keyExchange.ts
-import { decode as decode14, types as types15 } from "@shinyoshiaki/binary-data";
-
 // ../dtls/src/util/binary.ts
-import { encode as encode15 } from "@shinyoshiaki/binary-data";
+var { encode: encode16 } = binaryData_exports;
 function encodeBuffer(obj, spec) {
-  return Buffer.from(encode15(obj, spec).slice());
+  return encode16(obj, spec);
 }
 
 // ../dtls/src/handshake/message/server/keyExchange.ts
+var { decode: decode15, types: types16 } = binaryData_exports;
 var ServerKeyExchange = class _ServerKeyExchange {
   constructor(ellipticCurveType, namedCurve, publicKeyLength, publicKey, hashAlgorithm, signatureAlgorithm, signatureLength, signature) {
     this.ellipticCurveType = ellipticCurveType;
@@ -2811,14 +3120,14 @@ var ServerKeyExchange = class _ServerKeyExchange {
   msgType = 12 /* server_key_exchange_12 */;
   messageSeq;
   static spec = {
-    ellipticCurveType: types15.uint8,
-    namedCurve: types15.uint16be,
-    publicKeyLength: types15.uint8,
-    publicKey: types15.buffer((ctx) => ctx.current.publicKeyLength),
-    hashAlgorithm: types15.uint8,
-    signatureAlgorithm: types15.uint8,
-    signatureLength: types15.uint16be,
-    signature: types15.buffer((ctx) => ctx.current.signatureLength)
+    ellipticCurveType: types16.uint8,
+    namedCurve: types16.uint16be,
+    publicKeyLength: types16.uint8,
+    publicKey: types16.buffer((ctx) => ctx.current.publicKeyLength),
+    hashAlgorithm: types16.uint8,
+    signatureAlgorithm: types16.uint8,
+    signatureLength: types16.uint16be,
+    signature: types16.buffer((ctx) => ctx.current.signatureLength)
   };
   static createEmpty() {
     return new _ServerKeyExchange(
@@ -2833,7 +3142,7 @@ var ServerKeyExchange = class _ServerKeyExchange {
     );
   }
   static deSerialize(buf) {
-    const res = decode14(buf, _ServerKeyExchange.spec);
+    const res = decode15(buf, _ServerKeyExchange.spec);
     return new _ServerKeyExchange(
       ...Object.values(res)
     );
@@ -5874,7 +6183,7 @@ handlers[14 /* server_hello_done_14 */] = ({ dtls }) => (msg) => {
 };
 
 // ../dtls/src/handshake/message/server/helloVerifyRequest.ts
-import { decode as decode15, encode as encode16, types as types16 } from "@shinyoshiaki/binary-data";
+var { decode: decode16, encode: encode17, types: types17 } = binaryData_exports;
 var ServerHelloVerifyRequest = class _ServerHelloVerifyRequest {
   constructor(serverVersion, cookie) {
     this.serverVersion = serverVersion;
@@ -5884,19 +6193,18 @@ var ServerHelloVerifyRequest = class _ServerHelloVerifyRequest {
   messageSeq;
   static spec = {
     serverVersion: ProtocolVersion,
-    cookie: types16.buffer(types16.uint8)
+    cookie: types17.buffer(types17.uint8)
   };
   static createEmpty() {
     return new _ServerHelloVerifyRequest(void 0, void 0);
   }
   static deSerialize(buf) {
     return new _ServerHelloVerifyRequest(
-      ...Object.values(decode15(buf, _ServerHelloVerifyRequest.spec))
+      ...Object.values(decode16(buf, _ServerHelloVerifyRequest.spec))
     );
   }
   serialize() {
-    const res = encode16(this, _ServerHelloVerifyRequest.spec).slice();
-    return Buffer.from(res);
+    return encode17(this, _ServerHelloVerifyRequest.spec);
   }
   get version() {
     return {
@@ -5918,7 +6226,6 @@ var ServerHelloVerifyRequest = class _ServerHelloVerifyRequest {
 };
 
 // ../dtls/src/socket.ts
-import { decode as decode19, types as types20 } from "@shinyoshiaki/binary-data";
 import { setTimeout as setTimeout3 } from "timers/promises";
 
 // ../dtls/src/context/dtls.ts
@@ -5983,12 +6290,12 @@ var TransportContext = class {
 };
 
 // ../dtls/src/handshake/extensions/ellipticCurves.ts
-import { decode as decode16, encode as encode17, types as types17 } from "@shinyoshiaki/binary-data";
+var { decode: decode17, encode: encode18, types: types18 } = binaryData_exports;
 var EllipticCurves = class _EllipticCurves {
   static type = 10;
   static spec = {
-    type: types17.uint16be,
-    data: types17.array(types17.uint16be, types17.uint16be, "bytes")
+    type: types18.uint16be,
+    data: types18.array(types18.uint16be, types18.uint16be, "bytes")
   };
   type = _EllipticCurves.type;
   data = [];
@@ -6001,14 +6308,14 @@ var EllipticCurves = class _EllipticCurves {
   static fromData(buf) {
     return new _EllipticCurves({
       type: _EllipticCurves.type,
-      data: decode16(buf, _EllipticCurves.spec.data)
+      data: decode17(buf, _EllipticCurves.spec.data)
     });
   }
   static deSerialize(buf) {
-    return new _EllipticCurves(decode16(buf, _EllipticCurves.spec));
+    return new _EllipticCurves(decode17(buf, _EllipticCurves.spec));
   }
   serialize() {
-    return Buffer.from(encode17(this, _EllipticCurves.spec).slice());
+    return encode18(this, _EllipticCurves.spec);
   }
   get extension() {
     return {
@@ -6019,14 +6326,14 @@ var EllipticCurves = class _EllipticCurves {
 };
 
 // ../dtls/src/handshake/extensions/signature.ts
-import { decode as decode17, encode as encode18, types as types18 } from "@shinyoshiaki/binary-data";
+var { decode: decode18, encode: encode19, types: types19 } = binaryData_exports;
 var Signature = class _Signature {
   static type = 13;
   static spec = {
-    type: types18.uint16be,
-    data: types18.array(
-      { hash: types18.uint8, signature: types18.uint8 },
-      types18.uint16be,
+    type: types19.uint16be,
+    data: types19.array(
+      { hash: types19.uint8, signature: types19.uint8 },
+      types19.uint16be,
       "bytes"
     )
   };
@@ -6040,11 +6347,10 @@ var Signature = class _Signature {
     return v;
   }
   static deSerialize(buf) {
-    return new _Signature(decode17(buf, _Signature.spec));
+    return new _Signature(decode18(buf, _Signature.spec));
   }
   serialize() {
-    const res = encode18(this, _Signature.spec).slice();
-    return Buffer.from(res);
+    return encode19(this, _Signature.spec);
   }
   static fromData(buf) {
     const type = Buffer.alloc(2);
@@ -6060,24 +6366,23 @@ var Signature = class _Signature {
 };
 
 // ../dtls/src/handshake/message/alert.ts
-import { decode as decode18, encode as encode19, types as types19 } from "@shinyoshiaki/binary-data";
+var { decode: decode19, encode: encode20, types: types20 } = binaryData_exports;
 var Alert = class _Alert {
   constructor(level, description) {
     this.level = level;
     this.description = description;
   }
   static spec = {
-    level: types19.uint8,
-    description: types19.uint8
+    level: types20.uint8,
+    description: types20.uint8
   };
   static deSerialize(buf) {
     return new _Alert(
-      ...Object.values(decode18(buf, _Alert.spec))
+      ...Object.values(decode19(buf, _Alert.spec))
     );
   }
   serialize() {
-    const res = encode19(this, _Alert.spec).slice();
-    return Buffer.from(res);
+    return encode20(this, _Alert.spec);
   }
 };
 
@@ -6173,6 +6478,7 @@ var parsePlainText = (dtls, cipher) => (plain) => {
 };
 
 // ../dtls/src/socket.ts
+var { decode: decode20, types: types21 } = binaryData_exports;
 var log13 = debug("werift-dtls : packages/dtls/src/socket.ts : log");
 var err4 = debug("werift-dtls : packages/dtls/src/socket.ts : err");
 var DtlsSocket = class {
@@ -6332,13 +6638,13 @@ var DtlsSocket = class {
       "EXTRACTOR-dtls_srtp",
       keyLength2 * 2 + saltLength2 * 2
     );
-    const { clientKey, serverKey, clientSalt, serverSalt } = decode19(
+    const { clientKey, serverKey, clientSalt, serverSalt } = decode20(
       keyingMaterial,
       {
-        clientKey: types20.buffer(keyLength2),
-        serverKey: types20.buffer(keyLength2),
-        clientSalt: types20.buffer(saltLength2),
-        serverSalt: types20.buffer(saltLength2)
+        clientKey: types21.buffer(keyLength2),
+        serverKey: types21.buffer(keyLength2),
+        clientSalt: types21.buffer(saltLength2),
+        serverSalt: types21.buffer(saltLength2)
       }
     );
     if (this.sessionType === SessionType.CLIENT) {
@@ -6931,20 +7237,20 @@ function encodeTcpFrame(data) {
   header.writeUInt16BE(data.length, 0);
   return Buffer.concat([header, data]);
 }
-function splitTcpFrames(buffer2) {
+function splitTcpFrames(buffer3) {
   const frames = [];
   let offset = 0;
-  while (buffer2.length - offset >= 2) {
-    const length = buffer2.readUInt16BE(offset);
-    if (buffer2.length - offset < length + 2) {
+  while (buffer3.length - offset >= 2) {
+    const length = buffer3.readUInt16BE(offset);
+    if (buffer3.length - offset < length + 2) {
       break;
     }
-    frames.push(buffer2.subarray(offset + 2, offset + 2 + length));
+    frames.push(buffer3.subarray(offset + 2, offset + 2 + length));
     offset += 2 + length;
   }
   return {
     frames,
-    rest: buffer2.subarray(offset)
+    rest: buffer3.subarray(offset)
   };
 }
 
@@ -7025,11 +7331,11 @@ function isIpV4Address(address) {
 function packAddress(value) {
   const [address] = value;
   const protocol = isIpV4Address(address) ? IPV4_PROTOCOL : IPV6_PROTOCOL;
-  const buffer2 = Buffer.alloc(4);
-  buffer2.writeUInt8(0, 0);
-  buffer2.writeUInt8(protocol, 1);
-  buffer2.writeUInt16BE(value[1], 2);
-  return Buffer.concat([buffer2, ipAddressToBuffer(address)]);
+  const buffer3 = Buffer.alloc(4);
+  buffer3.writeUInt8(0, 0);
+  buffer3.writeUInt8(protocol, 1);
+  buffer3.writeUInt16BE(value[1], 2);
+  return Buffer.concat([buffer3, ipAddressToBuffer(address)]);
 }
 function unpackErrorCode(data) {
   if (data.length < 4) {
@@ -7080,19 +7386,19 @@ function unpackXorAddress(data, transactionId) {
   return unpackAddress(xorAddress(data, transactionId));
 }
 function packErrorCode(value) {
-  const buffer2 = Buffer.alloc(4);
-  buffer2.writeUInt16BE(0, 0);
-  buffer2.writeUInt8(Math.floor(value[0] / 100), 2);
-  buffer2.writeUInt8(value[0] % 100, 3);
+  const buffer3 = Buffer.alloc(4);
+  buffer3.writeUInt16BE(0, 0);
+  buffer3.writeUInt8(Math.floor(value[0] / 100), 2);
+  buffer3.writeUInt8(value[0] % 100, 3);
   const encoded = Buffer.from(value[1], "utf8");
-  return Buffer.concat([buffer2, encoded]);
+  return Buffer.concat([buffer3, encoded]);
 }
 function packUnknownAttributes(value) {
-  const buffer2 = Buffer.alloc(value.length * 2);
+  const buffer3 = Buffer.alloc(value.length * 2);
   value.forEach((attributeType, index) => {
-    buffer2.writeUInt16BE(attributeType, index * 2);
+    buffer3.writeUInt16BE(attributeType, index * 2);
   });
-  return buffer2;
+  return buffer3;
 }
 function unpackUnknownAttributes(data) {
   if (data.length % 2 !== 0) {
@@ -7108,21 +7414,21 @@ function packXorAddress(value, transactionId) {
   return xorAddress(packAddress(value), transactionId);
 }
 var packUnsigned = (value) => {
-  const buffer2 = Buffer.alloc(4);
-  buffer2.writeUInt32BE(value, 0);
-  return buffer2;
+  const buffer3 = Buffer.alloc(4);
+  buffer3.writeUInt32BE(value, 0);
+  return buffer3;
 };
 var unpackUnsigned = (data) => data.readUInt32BE(0);
 var packUnsignedShort = (value) => {
-  const buffer2 = Buffer.alloc(4);
-  buffer2.writeUInt16BE(value, 0);
-  return buffer2;
+  const buffer3 = Buffer.alloc(4);
+  buffer3.writeUInt16BE(value, 0);
+  return buffer3;
 };
 var unpackUnsignedShort = (data) => data.readUInt16BE(0);
 var packUnsigned64 = (value) => {
-  const buffer2 = Buffer.allocUnsafe(8);
-  buffer2.writeBigUInt64BE(value, 0);
-  return buffer2;
+  const buffer3 = Buffer.allocUnsafe(8);
+  buffer3.writeBigUInt64BE(value, 0);
+  return buffer3;
 };
 var unpackUnsigned64 = (data) => data.readBigUInt64BE(0);
 var packString = (value) => Buffer.from(value, "utf8");
@@ -8155,35 +8461,35 @@ function padTurnFrame(data) {
   const padding = paddingLength(data.length);
   return padding > 0 ? Buffer.concat([data, Buffer.alloc(padding)]) : data;
 }
-function splitTurnTcpFrames(buffer2) {
+function splitTurnTcpFrames(buffer3) {
   const frames = [];
   let offset = 0;
   let malformed = false;
-  while (buffer2.length - offset >= 4) {
+  while (buffer3.length - offset >= 4) {
     let frameLength;
-    if (isChannelData(buffer2.subarray(offset))) {
-      const payloadLength = buffer2.readUInt16BE(offset + 2);
+    if (isChannelData(buffer3.subarray(offset))) {
+      const payloadLength = buffer3.readUInt16BE(offset + 2);
       frameLength = 4 + payloadLength + paddingLength(payloadLength);
-    } else if ((buffer2[offset] & 192) === 0) {
-      if (buffer2.length - offset < 20) {
+    } else if ((buffer3[offset] & 192) === 0) {
+      if (buffer3.length - offset < 20) {
         break;
       }
-      const stunBodyLength = buffer2.readUInt16BE(offset + 2);
+      const stunBodyLength = buffer3.readUInt16BE(offset + 2);
       frameLength = 20 + stunBodyLength + paddingLength(stunBodyLength);
     } else {
       malformed = true;
       break;
     }
-    if (buffer2.length - offset < frameLength) {
+    if (buffer3.length - offset < frameLength) {
       break;
     }
-    frames.push(buffer2.subarray(offset, offset + frameLength));
+    frames.push(buffer3.subarray(offset, offset + frameLength));
     offset += frameLength;
   }
   return {
     frames,
     malformed,
-    rest: buffer2.subarray(offset)
+    rest: buffer3.subarray(offset)
   };
 }
 
@@ -15801,11 +16107,11 @@ var RtpRouter = class {
   }
   registerRtpReceiverBySsrc(transceiver, params) {
     log33("registerRtpReceiverBySsrc", params);
-    params.encodings.filter((e) => e.ssrc != void 0).forEach((encode20, i) => {
-      this.registerRtpReceiver(transceiver.receiver, encode20.ssrc);
+    params.encodings.filter((e) => e.ssrc != void 0).forEach((encode21, i) => {
+      this.registerRtpReceiver(transceiver.receiver, encode21.ssrc);
       transceiver.addTrack(
         new MediaStreamTrack({
-          ssrc: encode20.ssrc,
+          ssrc: encode21.ssrc,
           kind: transceiver.kind,
           id: transceiver.sender.trackId,
           remote: true,
@@ -15816,8 +16122,8 @@ var RtpRouter = class {
           )
         })
       );
-      if (encode20.rtx) {
-        this.registerRtpReceiver(transceiver.receiver, encode20.rtx.ssrc);
+      if (encode21.rtx) {
+        this.registerRtpReceiver(transceiver.receiver, encode21.rtx.ssrc);
       }
     });
     params.headerExtensions.forEach((extension) => {
@@ -21845,18 +22151,18 @@ var JitterBufferBase = class {
     return resolve2;
   }
   sortAndClearBuffer(rtpBuffer) {
-    const buffer2 = [];
+    const buffer3 = [];
     for (let index = this.presentSeqNum ?? 0; ; index = uint16Add(index, 1)) {
       const rtp = rtpBuffer[index];
       if (rtp) {
-        buffer2.push(rtp);
+        buffer3.push(rtp);
         delete rtpBuffer[index];
       }
       if (Object.values(rtpBuffer).length === 0) {
         break;
       }
     }
-    return buffer2;
+    return buffer3;
   }
   disposeTimeoutPackets(baseTimestamp) {
     let latestTimeoutSeqNum;
@@ -22527,16 +22833,16 @@ function containsH264ParameterSets(nalUnits) {
 function looksLikeAnnexB(sample) {
   return sample.length >= 4 && sample[0] === 0 && sample[1] === 0 && (sample[2] === 0 && sample[3] === 1 || sample[2] === 1);
 }
-function readUintLength(buffer2, offset, length) {
+function readUintLength(buffer3, offset, length) {
   switch (length) {
     case 1:
-      return buffer2.readUInt8(offset);
+      return buffer3.readUInt8(offset);
     case 2:
-      return buffer2.readUInt16BE(offset);
+      return buffer3.readUInt16BE(offset);
     case 3:
-      return buffer2.readUIntBE(offset, 3);
+      return buffer3.readUIntBE(offset, 3);
     case 4:
-      return buffer2.readUInt32BE(offset);
+      return buffer3.readUInt32BE(offset);
     default:
       throw new Error(`unsupported H264 NALU length size: ${length}`);
   }
@@ -22909,14 +23215,14 @@ async function createReplayableSource(options) {
   if (typeof options.path === "string") {
     return { path: options.path };
   }
-  const buffer2 = options.buffer != void 0 ? toBuffer2(options.buffer) : await readStreamToBuffer(options.stream);
-  return { buffer: buffer2 };
+  const buffer3 = options.buffer != void 0 ? toBuffer2(options.buffer) : await readStreamToBuffer(options.stream);
+  return { buffer: buffer3 };
 }
 async function createInput(options) {
   if (typeof options.path === "string") {
-    const buffer2 = await readFile(resolveUserMediaPath(options.path));
+    const buffer3 = await readFile(resolveUserMediaPath(options.path));
     return new Input({
-      source: new BufferSource(buffer2),
+      source: new BufferSource(buffer3),
       formats: [MP4, WEBM]
     });
   }
@@ -23377,8 +23683,8 @@ async function readEntireStream(stream, signal = new AbortController().signal) {
   }
   return Buffer.concat(chunks);
 }
-function isWebmContainer(buffer2) {
-  return buffer2.length >= 4 && buffer2[0] === 26 && buffer2[1] === 69 && buffer2[2] === 223 && buffer2[3] === 163;
+function isWebmContainer(buffer3) {
+  return buffer3.length >= 4 && buffer3[0] === 26 && buffer3[1] === 69 && buffer3[2] === 223 && buffer3[3] === 163;
 }
 
 // src/polyfill/registers/mp4Webm.ts
@@ -23497,9 +23803,9 @@ function initialMimeType(options) {
   const kinds = initialKinds(options);
   return mimeTypeFromContainer(containerOf(options), kinds);
 }
-function containerOf(options, buffer2) {
-  if (buffer2) {
-    return isWebmContainer(buffer2) ? "webm" : "mp4";
+function containerOf(options, buffer3) {
+  if (buffer3) {
+    return isWebmContainer(buffer3) ? "webm" : "mp4";
   }
   if ("path" in options && options.path != void 0) {
     return containerFromPath(options.path);
@@ -23542,21 +23848,21 @@ function mimeTypeFromContainer(container, kinds) {
   }
   return hasVideo ? "video/mp4" : "audio/mp4";
 }
-function inspectKindsFromBuffer(buffer2) {
+function inspectKindsFromBuffer(buffer3) {
   try {
-    const kinds = isWebmContainer(buffer2) ? inspectWebmKinds(buffer2) : inspectMp4Kinds(buffer2);
+    const kinds = isWebmContainer(buffer3) ? inspectWebmKinds(buffer3) : inspectMp4Kinds(buffer3);
     return kinds.length > 0 ? kinds : void 0;
   } catch {
     return void 0;
   }
 }
-function inspectMp4Kinds(buffer2) {
+function inspectMp4Kinds(buffer3) {
   const found = /* @__PURE__ */ new Set();
-  for (let index = 4; index < buffer2.length - 16; index++) {
-    if (buffer2.toString("ascii", index, index + 4) !== "hdlr") {
+  for (let index = 4; index < buffer3.length - 16; index++) {
+    if (buffer3.toString("ascii", index, index + 4) !== "hdlr") {
       continue;
     }
-    const handler = buffer2.toString("ascii", index + 12, index + 16);
+    const handler = buffer3.toString("ascii", index + 12, index + 16);
     if (handler === "soun") {
       found.add("audio");
     } else if (handler === "vide") {
@@ -23565,13 +23871,13 @@ function inspectMp4Kinds(buffer2) {
   }
   return [...found];
 }
-function inspectWebmKinds(buffer2) {
+function inspectWebmKinds(buffer3) {
   const found = /* @__PURE__ */ new Set();
-  for (let index = 0; index < buffer2.length - 2; index++) {
-    if (buffer2[index] !== 131 || buffer2[index + 1] !== 129) {
+  for (let index = 0; index < buffer3.length - 2; index++) {
+    if (buffer3[index] !== 131 || buffer3[index + 1] !== 129) {
       continue;
     }
-    const trackType = buffer2[index + 2];
+    const trackType = buffer3[index + 2];
     if (trackType === 1) {
       found.add("video");
     } else if (trackType === 2) {