werift 0.25.0-alpha.0 → 0.25.1

package/lib/nonstandard/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 });
+};
+
 // ../rtp/src/extra/container/mp4/container.ts
 import {
   EncodedAudioPacketSource,
@@ -23,19 +29,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;
@@ -927,6 +933,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
+};
+
 // ../rtp/src/extra/container/mp4/container.ts
 var Mp4Container = class {
   constructor(props) {
@@ -2629,7 +2960,7 @@ var decodeVintEncodedNumber = (buf, offset = 0) => {
   }
   return { value, length };
 };
-var string = (str) => {
+var string2 = (str) => {
   return bytes(stringToByteArray(str));
 };
 var element = (id, child) => {
@@ -2961,7 +3292,7 @@ var WEBMContainer = class {
       element(ID.EBMLReadVersion, number(1)),
       element(ID.EBMLMaxIDLength, number(4)),
       element(ID.EBMLMaxSizeLength, number(8)),
-      element(ID.DocType, string("webm")),
+      element(ID.DocType, string2("webm")),
       element(ID.DocTypeVersion, number(2)),
       element(ID.DocTypeReadVersion, number(2))
     ])
@@ -3051,11 +3382,11 @@ var WEBMContainer = class {
     const trackEntry = element(ID.TrackEntry, [
       element(ID.TrackNumber, number(trackNumber)),
       element(ID.TrackUID, number(trackNumber)),
-      element(ID.CodecName, string(codec)),
+      element(ID.CodecName, string2(codec)),
       element(ID.TrackType, number(kind === "video" ? 1 : 2)),
       element(
         ID.CodecID,
-        string(`${kind === "video" ? "V" : "A"}_${codec}`)
+        string2(`${kind === "video" ? "V" : "A"}_${codec}`)
       ),
       ...trackElements
     ]);
@@ -3064,8 +3395,8 @@ var WEBMContainer = class {
   createSegment(duration) {
     const elements = [
       element(ID.TimecodeScale, number(millisecond)),
-      element(ID.MuxingApp, string("webrtc")),
-      element(ID.WritingApp, string("webrtc"))
+      element(ID.MuxingApp, string2("webrtc")),
+      element(ID.WritingApp, string2("webrtc"))
     ];
     if (duration != void 0) {
       elements.push(element(ID.Duration, float(duration)));
@@ -5878,18 +6209,18 @@ var JitterBufferBase = class {
     return resolve;
   }
   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;
@@ -6066,7 +6397,7 @@ var LipsyncBase = class {
     }
     this.processInput(frame, this.videoBuffer, "video");
   };
-  processInput = (frame, buffer2, kind) => {
+  processInput = (frame, buffer3, kind) => {
     if (this.stopped) {
       return;
     }
@@ -6096,7 +6427,7 @@ var LipsyncBase = class {
     this.lastFrameReceivedAt = now;
     const elapsed = frame.time - this.baseTime;
     const index = int(elapsed / this.bufferDuration) % this.bufferLength;
-    buffer2[index].push({
+    buffer3[index].push({
       frame,
       kind
     });
@@ -6318,10 +6649,10 @@ function avccToCodecString(avcc) {
 function toHex(value) {
   return value.toString(16).padStart(2, "0");
 }
-function toArrayBuffer(buffer2) {
-  return buffer2.buffer.slice(
-    buffer2.byteOffset,
-    buffer2.byteOffset + buffer2.byteLength
+function toArrayBuffer(buffer3) {
+  return buffer3.buffer.slice(
+    buffer3.byteOffset,
+    buffer3.byteOffset + buffer3.byteLength
   );
 }
 
@@ -6403,13 +6734,13 @@ var MuteHandlerBase = class {
   }
   executeTask() {
     const { ptime, dummyPacket } = this.props;
-    const buffer2 = this.buffer[this.index].sort((a, b) => a.time - b.time);
-    const last = buffer2.at(-1);
+    const buffer3 = this.buffer[this.index].sort((a, b) => a.time - b.time);
+    const last = buffer3.at(-1);
     const expect = last ? last.time + // offset
     ptime : this.currentTimestamp;
     if (expect < this.currentTimestamp + this.bufferDuration) {
       for (let time = expect; time < this.currentTimestamp + this.bufferDuration; time += ptime) {
-        buffer2.push({
+        buffer3.push({
           time,
           data: dummyPacket,
           isKeyframe: true
@@ -6419,7 +6750,7 @@ var MuteHandlerBase = class {
     this.currentTimestamp += this.bufferDuration;
     this.internalStats["mute"] = (/* @__PURE__ */ new Date()).toISOString();
     this.buffer[this.index] = [];
-    buffer2.forEach((frame) => {
+    buffer3.forEach((frame) => {
       this.output({ frame });
       this.lastCommittedTime = frame.time;
     });
@@ -7345,7 +7676,6 @@ import { createSocket as createSocket3 } from "dgram";
 import { createSign, randomBytes as randomBytes3, 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 = {
@@ -7375,7 +7705,6 @@ var signatures = [
 
 // ../dtls/src/cipher/prf.ts
 import { createHash, createHmac as createHmac3 } from "crypto";
-import { createDecode } from "@shinyoshiaki/binary-data";
 import nacl from "tweetnacl";
 
 // ../dtls/src/cipher/ec.ts
@@ -7471,7 +7800,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);
@@ -7525,6 +7854,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 {
@@ -7670,15 +8000,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]);
   }
@@ -7694,12 +8022,6 @@ var SrtpContext2 = 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]) => {
@@ -7713,6 +8035,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;
@@ -7723,12 +8046,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);
@@ -7745,12 +8068,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;
@@ -7823,46 +8145,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: string2 } = types3;
+var { types: types4 } = binaryData_exports;
+var { uint16be, uint24be, buffer: buffer2, array: array2, uint8, string: string3 } = 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 = string2(uint16be);
+var DistinguishedName = string3(uint16be);
 var SignatureHashAlgorithm = { hash: uint8, signature: uint8 };
 var ProtocolVersion = { major: uint8, minor: uint8 };
 
 // ../dtls/src/handshake/random.ts
 import { randomBytes as randomBytes4 } 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 = randomBytes4(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;
@@ -7876,12 +8198,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() {
@@ -7897,12 +8219,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();
@@ -7918,7 +8239,7 @@ var ClientHello = class _ClientHello {
 };
 
 // ../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;
@@ -7928,11 +8249,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(
@@ -7945,12 +8266,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);
   }
 };
 
@@ -8341,12 +8661,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;
@@ -8359,12 +8679,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 {
@@ -8375,13 +8694,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([]);
@@ -8398,7 +8717,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++) {
@@ -8421,8 +8740,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);
@@ -8439,7 +8757,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;
@@ -8447,19 +8765,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();
@@ -8475,30 +8792,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;
@@ -8507,21 +8823,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();
@@ -8537,7 +8852,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;
@@ -8545,20 +8860,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();
@@ -8574,7 +8888,7 @@ var ClientKeyExchange = class _ClientKeyExchange {
 };
 
 // ../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;
@@ -8584,9 +8898,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(
@@ -8597,12 +8911,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();
@@ -8618,7 +8931,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;
@@ -8633,9 +8946,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(
@@ -8648,7 +8961,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)
     );
@@ -8656,18 +8969,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();
@@ -8683,18 +8995,16 @@ var ServerHello = class _ServerHello {
 };
 
 // ../dtls/src/handshake/message/server/helloDone.ts
-import { decode as decode13, encode as encode14 } from "@shinyoshiaki/binary-data";
-
-// ../dtls/src/handshake/message/server/keyExchange.ts
-import { decode as decode14, types as types15 } from "@shinyoshiaki/binary-data";
+var { decode: decode14, encode: encode15 } = binaryData_exports;
 
 // ../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;
@@ -8709,14 +9019,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(
@@ -8731,7 +9041,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)
     );
@@ -8812,7 +9122,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;
@@ -8822,19 +9132,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 {
@@ -8855,19 +9164,16 @@ var ServerHelloVerifyRequest = class _ServerHelloVerifyRequest {
   }
 };
 
-// ../dtls/src/socket.ts
-import { decode as decode19, types as types20 } from "@shinyoshiaki/binary-data";
-
 // ../dtls/src/context/dtls.ts
 var log12 = debug("werift-dtls : packages/dtls/src/context/dtls.ts : log");
 
 // ../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 = [];
@@ -8880,14 +9186,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 {
@@ -8898,14 +9204,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"
     )
   };
@@ -8919,11 +9225,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);
@@ -8939,24 +9244,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);
   }
 };
 
@@ -8965,6 +9269,7 @@ var log13 = debug("werift-dtls : packages/dtls/record/receive.ts : log");
 var err3 = debug("werift-dtls : packages/dtls/record/receive.ts : err");
 
 // ../dtls/src/socket.ts
+var { decode: decode20, types: types21 } = binaryData_exports;
 var log14 = debug("werift-dtls : packages/dtls/src/socket.ts : log");
 var err4 = debug("werift-dtls : packages/dtls/src/socket.ts : err");
 
@@ -9107,11 +9412,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) {
@@ -9162,19 +9467,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) {
@@ -9190,21 +9495,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");
@@ -10701,6 +11006,7 @@ export {
   WeriftError,
   annexb2avcSample,
   annexb2avcc,
+  binaryData_exports as binaryData,
   buffer2ArrayBuffer,
   bufferArrayXor,
   bufferReader,
@@ -10767,7 +11073,7 @@ export {
   serializeSdesRTPStreamID,
   serializeSimpleBlock,
   serializeTransportWideCC,
-  string,
+  string2 as string,
   stringToByteArray,
   timer,
   uint16Add,