werift 0.25.0 → 0.25.1

package/lib/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 });
+};
+
 // ../common/src/binary.ts
 import { randomBytes } from "crypto";
 function random16() {
@@ -13,19 +19,19 @@ function bufferXor(a, b) {
     );
   }
   const length = a.length;
-  const buffer2 = Buffer.allocUnsafe(length);
+  const buffer3 = Buffer.allocUnsafe(length);
   for (let i = 0; i < length; i++) {
-    buffer2[i] = a[i] ^ b[i];
+    buffer3[i] = a[i] ^ b[i];
   }
-  return buffer2;
+  return buffer3;
 }
 function bufferArrayXor(arr) {
   const length = [...arr].sort((a, b) => a.length - b.length).reverse()[0].length;
   const xored = Buffer.allocUnsafe(length);
   for (let i = 0; i < length; i++) {
     xored[i] = 0;
-    arr.forEach((buffer2) => {
-      xored[i] ^= buffer2[i] ?? 0;
+    arr.forEach((buffer3) => {
+      xored[i] ^= buffer3[i] ?? 0;
     });
   }
   return xored;
@@ -917,11 +923,335 @@ 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 bytes = 0;
+        while (bytes < expectedSize) {
+          items.push(decodeCommon(reader, type, context));
+          bytes = reader.bytes - before;
+        }
+        if (bytes > 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
+};
+
 // ../dtls/src/context/cipher.ts
 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 = {
@@ -961,7 +1291,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
@@ -1063,7 +1392,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);
@@ -1117,6 +1446,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 {
@@ -1262,15 +1592,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]);
   }
@@ -1286,12 +1614,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 dumpBuffer2 = (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]) => {
@@ -1305,6 +1627,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;
@@ -1315,12 +1638,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);
@@ -1337,12 +1660,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;
@@ -1415,46 +1737,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;
@@ -1468,12 +1790,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() {
@@ -1489,12 +1811,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();
@@ -1513,7 +1834,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;
@@ -1523,11 +1844,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(
@@ -1540,12 +1861,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);
   }
 };
 
@@ -1593,15 +1913,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(
@@ -2159,12 +2479,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;
@@ -2177,12 +2497,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 {
@@ -2193,13 +2512,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([]);
@@ -2216,7 +2535,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++) {
@@ -2239,8 +2558,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);
@@ -2257,7 +2575,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;
@@ -2265,19 +2583,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();
@@ -2293,30 +2610,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;
@@ -2325,21 +2641,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();
@@ -2355,7 +2670,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;
@@ -2363,20 +2678,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();
@@ -2421,7 +2735,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;
@@ -2431,9 +2745,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(
@@ -2444,12 +2758,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();
@@ -2465,7 +2778,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;
@@ -2480,9 +2793,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(
@@ -2495,7 +2808,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)
     );
@@ -2503,18 +2816,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();
@@ -2530,7 +2842,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;
@@ -2540,12 +2852,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();
@@ -2560,16 +2871,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;
@@ -2584,14 +2893,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(
@@ -2606,7 +2915,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)
     );
@@ -5716,7 +6025,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;
@@ -5726,19 +6035,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 {
@@ -5760,7 +6068,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
@@ -5825,12 +6132,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 = [];
@@ -5843,14 +6150,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 {
@@ -5861,14 +6168,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"
     )
   };
@@ -5882,11 +6189,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);
@@ -5902,24 +6208,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);
   }
 };
 
@@ -6015,6 +6320,7 @@ var parsePlainText = (dtls, cipher) => (plain) => {
 };
 
 // ../dtls/src/socket.ts
+var { decode: decode20, types: types21 } = binaryData_exports;
 var log12 = debug("werift-dtls : packages/dtls/src/socket.ts : log");
 var err4 = debug("werift-dtls : packages/dtls/src/socket.ts : err");
 var DtlsSocket = class {
@@ -6174,13 +6480,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) {
@@ -6788,20 +7094,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)
   };
 }
 
@@ -6882,11 +7188,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) {
@@ -6937,19 +7243,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) {
@@ -6965,21 +7271,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");
@@ -8012,35 +8318,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)
   };
 }
 
@@ -16166,11 +16472,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,
@@ -16181,8 +16487,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) => {
@@ -20673,6 +20979,7 @@ export {
   andDirection,
   applyCodecPreferences,
   assertCodecsSupported,
+  binaryData_exports as binaryData,
   buffer2ArrayBuffer,
   bufferArrayXor,
   bufferReader,