werift 0.22.1 → 0.22.3

package/lib/nonstandard/index.mjs

@@ -193,7 +193,10 @@ var BitStream = class {
     }
     return this;
   }
-  readBits(bits, bitBuffer) {
+  readBits(bits) {
+    return this._readBits(bits);
+  }
+  _readBits(bits, bitBuffer) {
     if (typeof bitBuffer == "undefined") {
       bitBuffer = 0;
     }
@@ -214,7 +217,7 @@ var BitStream = class {
     }
     bits -= bitsConsumed;
     bitBuffer = bitBuffer << bitsConsumed | partial;
-    return bits > 0 ? this.readBits(bits, bitBuffer) : bitBuffer;
+    return bits > 0 ? this._readBits(bits, bitBuffer) : bitBuffer;
   }
   seekTo(bitPos) {
     this.position = bitPos / 8 | 0;
@@ -438,6 +441,11 @@ var Event = class {
     };
     return { unSubscribe, disposer };
   };
+  pipe(e) {
+    this.subscribe((...args) => {
+      e.execute(...args);
+    });
+  }
   queuingSubscribe = (execute, complete, error) => {
     if (this.ended) throw new Error("event completed");
     const id = this.event.eventId;
@@ -522,6 +530,7 @@ var EventDisposer = class {
 import {
   createSocket as createSocket2
 } from "dgram";
+import net from "net";
 import { connect } from "net";
 var log = debug("werift-ice:packages/ice/src/transport.ts");
 var UdpTransport = class _UdpTransport {
@@ -546,6 +555,7 @@ var UdpTransport = class _UdpTransport {
   rinfo;
   onData = () => {
   };
+  closed = false;
   static async init(type, options = {}) {
     const transport = new _UdpTransport(type, options);
     await transport.init();
@@ -571,17 +581,23 @@ var UdpTransport = class _UdpTransport {
     }
     await new Promise((r) => this.socket.once("listening", r));
   }
-  send = (data, addr) => new Promise((r, f) => {
-    addr = addr ?? [this.rinfo?.address, this.rinfo?.port];
-    this.socket.send(data, addr[1], addr[0], (error) => {
-      if (error) {
-        log("send error", addr, data);
-        f(error);
-      } else {
-        r();
-      }
-    });
-  });
+  send = async (data, addr) => {
+    if (addr && !net.isIP(addr[0])) {
+      return new Promise((r, f) => {
+        this.socket.send(data, addr[1], addr[0], (error) => {
+          if (error) {
+            log("send error", addr, data);
+            f(error);
+          } else {
+            r();
+          }
+        });
+      });
+    } else {
+      addr = addr ?? [this.rinfo?.address, this.rinfo?.port];
+      this.socket.send(data, addr[1], addr[0]);
+    }
+  };
   get address() {
     return this.socket.address();
   }
@@ -592,6 +608,7 @@ var UdpTransport = class _UdpTransport {
     return this.socket.address().port;
   }
   close = () => new Promise((r) => {
+    this.closed = true;
     this.socket.once("close", r);
     try {
       this.socket.close();
@@ -818,7 +835,7 @@ var Mp4Container = class {
       throw new Error("bufferFrame missing");
     }
     const duration = frame.timestamp - bufferFrame.timestamp;
-    const buffer2 = new Uint8Array(bufferFrame.byteLength);
+    const buffer2 = new ArrayBuffer(bufferFrame.byteLength);
     bufferFrame.copyTo(buffer2);
     this.#mp4.addSample(track, buffer2, {
       duration,
@@ -2202,6 +2219,13 @@ var float = (num) => bytes(float32bit(num));
 var vintEncodedNumber = (num) => {
   return bytes(vintEncode(numberToByteArray(num, getEBMLByteLength(num))));
 };
+var decodeVintEncodedNumber = (buf, offset = 0) => {
+  const { value, length, unknown } = vintDecode(buf, offset);
+  if (unknown || value === void 0) {
+    throw new Error("decodeVintEncodedNumber: value is unknown size sentinel");
+  }
+  return { value, length };
+};
 var string = (str) => {
   return bytes(stringToByteArray(str));
 };
@@ -2260,6 +2284,45 @@ var vintEncode = (byteArray) => {
 var getSizeMask = (byteLength) => {
   return 128 >> byteLength - 1;
 };
+var vintDecode = (buf, offset = 0) => {
+  if (offset >= buf.length) {
+    throw new Error("vintDecode: offset out of range");
+  }
+  const first = buf[offset];
+  if (first === 0) {
+    throw new Error("vintDecode: invalid first byte 0x00 (no leading 1 bit)");
+  }
+  let length = 0;
+  for (let i = 0; i < 8; i++) {
+    const mask = 128 >> i;
+    if (first & mask) {
+      length = i + 1;
+      break;
+    }
+  }
+  if (length === 0) {
+    throw new Error("vintDecode: could not determine length");
+  }
+  if (offset + length > buf.length) {
+    throw new Error("vintDecode: insufficient bytes for declared length");
+  }
+  const lengthMarker = getSizeMask(length);
+  let valueBig = BigInt(first & ~lengthMarker);
+  for (let i = 1; i < length; i++) {
+    valueBig = valueBig << 8n | BigInt(buf[offset + i]);
+  }
+  const allOnes = (1n << BigInt(7 * length)) - 1n;
+  const unknown = valueBig === allOnes;
+  let value;
+  if (unknown) {
+    value = void 0;
+  } else if (valueBig <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    value = Number(valueBig);
+  } else {
+    value = valueBig;
+  }
+  return { value, length, unknown };
+};
 
 // ../rtp/src/extra/container/webm/ebml/id.ts
 var ID = {
@@ -2530,17 +2593,19 @@ var WEBMContainer = class {
     if (kind === "video") {
       width ??= 640;
       height ??= 360;
-      roll ??= 0;
-      trackElements.push(
-        element(ID.Video, [
-          element(ID.PixelWidth, number(width)),
-          element(ID.PixelHeight, number(height)),
+      const videoElements = [
+        element(ID.PixelWidth, number(width)),
+        element(ID.PixelHeight, number(height))
+      ];
+      if (roll !== void 0) {
+        videoElements.push(
           element(ID.Projection, [
             element(ID.ProjectionType, number(0)),
             element(ID.ProjectionPoseRoll, float(roll))
           ])
-        ])
-      );
+        );
+      }
+      trackElements.push(element(ID.Video, videoElements));
     } else {
       trackElements.push(
         element(ID.Audio, [
@@ -2678,6 +2743,59 @@ var containerSupportedCodecs = [
 ];
 var millisecond = 1e6;
 
+// ../rtp/src/extra/container/webm/util.ts
+function serializeSimpleBlock(frame, isKeyframe, trackNumber, relativeTimestamp) {
+  const elementId = Buffer.from([163]);
+  const contentSize = vintEncodedNumber(
+    1 + 2 + 1 + frame.length
+  ).bytes;
+  const keyframe = isKeyframe ? 1 : 0;
+  const flags = new BitWriter2(8).set(keyframe).set(0, 3).set(0).set(0, 2).set(0);
+  const simpleBlock = Buffer.concat([
+    elementId,
+    contentSize,
+    vintEncodedNumber(trackNumber).bytes,
+    new BufferChain(2).writeInt16BE(relativeTimestamp).buffer,
+    new BufferChain(1).writeUInt8(flags.value).buffer,
+    frame
+  ]);
+  return simpleBlock;
+}
+function deserializeSimpleBlocks(data) {
+  const frames = [];
+  let position = 0;
+  while (position < data.length) {
+    const elementId = data[position];
+    if (elementId !== 163) {
+      throw new Error(`unexpected element id 0x${elementId.toString(16)}`);
+    }
+    position += 1;
+    const { value: contentSize, length: contentSizeLength } = decodeVintEncodedNumber(data, position);
+    position += contentSizeLength;
+    const { value: trackNumber, length: trackNumberLength } = decodeVintEncodedNumber(data, position);
+    position += trackNumberLength;
+    const timecode = data.readInt16BE(position);
+    position += 2;
+    const flags = new BitStream(data.subarray(position, position + 1));
+    const isKeyframe = flags.readBits(1) === 1;
+    position += 1;
+    const metaSize = trackNumberLength + 2 + 1;
+    const remaining = Number(contentSize) - metaSize;
+    if (remaining < 0) {
+      throw new Error("invalid simple block size");
+    }
+    const frame = data.subarray(position, position + remaining);
+    frames.push({
+      data: frame,
+      trackNumber: Number(trackNumber),
+      isKeyframe,
+      timecode
+    });
+    position += remaining;
+  }
+  return frames;
+}
+
 // ../rtp/src/srtp/const.ts
 var ProtectionProfileAes128CmHmacSha1_80 = 1;
 var ProtectionProfileAeadAes128Gcm = 7;
@@ -2745,6 +2863,16 @@ var RtcpHeader = class _RtcpHeader {
   constructor(props = {}) {
     Object.assign(this, props);
   }
+  static serialize(type, count, payload, length) {
+    const header = new _RtcpHeader({
+      type,
+      count,
+      version: 2,
+      length
+    });
+    const buf = header.serialize();
+    return Buffer.concat([buf, payload]);
+  }
   serialize() {
     const v_p_rc = new BitWriter(8);
     v_p_rc.set(2, 0, this.version);
@@ -2762,6 +2890,156 @@ var RtcpHeader = class _RtcpHeader {
   }
 };
 
+// ../rtp/src/rtcp/psfb/fullIntraRequest.ts
+var FullIntraRequest = class _FullIntraRequest {
+  static count = 4;
+  count = _FullIntraRequest.count;
+  senderSsrc;
+  mediaSsrc;
+  fir = [];
+  constructor(props = {}) {
+    Object.assign(this, props);
+  }
+  get length() {
+    return Math.floor(this.serialize().length / 4 - 1);
+  }
+  static deSerialize(data) {
+    const [senderSsrc, mediaSsrc] = bufferReader(data, [4, 4]);
+    const fir = [];
+    for (let i = 8; i < data.length; i += 8) {
+      fir.push({ ssrc: data.readUInt32BE(i), sequenceNumber: data[i + 4] });
+    }
+    return new _FullIntraRequest({ senderSsrc, mediaSsrc, fir });
+  }
+  serialize() {
+    const ssrcs = bufferWriter([4, 4], [this.senderSsrc, this.mediaSsrc]);
+    const fir = Buffer.alloc(this.fir.length * 8);
+    this.fir.forEach(({ ssrc, sequenceNumber }, i) => {
+      fir.writeUInt32BE(ssrc, i * 8);
+      fir[i * 8 + 4] = sequenceNumber;
+    });
+    return Buffer.concat([ssrcs, fir]);
+  }
+};
+
+// ../rtp/src/rtcp/psfb/pictureLossIndication.ts
+var PictureLossIndication = class _PictureLossIndication {
+  static count = 1;
+  count = _PictureLossIndication.count;
+  length = 2;
+  senderSsrc;
+  mediaSsrc;
+  constructor(props = {}) {
+    Object.assign(this, props);
+  }
+  static deSerialize(data) {
+    const [senderSsrc, mediaSsrc] = bufferReader(data, [4, 4]);
+    return new _PictureLossIndication({ senderSsrc, mediaSsrc });
+  }
+  serialize() {
+    return bufferWriter([4, 4], [this.senderSsrc, this.mediaSsrc]);
+  }
+};
+
+// ../rtp/src/rtcp/psfb/remb.ts
+var ReceiverEstimatedMaxBitrate = class _ReceiverEstimatedMaxBitrate {
+  static count = 15;
+  length;
+  count = _ReceiverEstimatedMaxBitrate.count;
+  senderSsrc;
+  mediaSsrc;
+  uniqueID = "REMB";
+  ssrcNum = 0;
+  brExp;
+  brMantissa;
+  bitrate;
+  ssrcFeedbacks = [];
+  constructor(props = {}) {
+    Object.assign(this, props);
+  }
+  static deSerialize(data) {
+    const [senderSsrc, mediaSsrc, uniqueID, ssrcNum, e_m] = bufferReader(
+      data,
+      [4, 4, 4, 1, 1]
+    );
+    const brExp = getBit(e_m, 0, 6);
+    const brMantissa = (getBit(e_m, 6, 2) << 16) + (data[14] << 8) + data[15];
+    const bitrate = brExp > 46 ? 18446744073709551615n : BigInt(brMantissa) << BigInt(brExp);
+    const ssrcFeedbacks = [];
+    for (let i = 16; i < data.length; i += 4) {
+      const feedback = data.slice(i).readUIntBE(0, 4);
+      ssrcFeedbacks.push(feedback);
+    }
+    return new _ReceiverEstimatedMaxBitrate({
+      senderSsrc,
+      mediaSsrc,
+      uniqueID: bufferWriter([4], [uniqueID]).toString(),
+      ssrcNum,
+      brExp,
+      brMantissa,
+      ssrcFeedbacks,
+      bitrate
+    });
+  }
+  serialize() {
+    const constant = Buffer.concat([
+      bufferWriter([4, 4], [this.senderSsrc, this.mediaSsrc]),
+      Buffer.from(this.uniqueID),
+      bufferWriter([1], [this.ssrcNum])
+    ]);
+    const writer = new BitWriter(24);
+    writer.set(6, 0, this.brExp).set(18, 6, this.brMantissa);
+    const feedbacks = Buffer.concat(
+      this.ssrcFeedbacks.map((feedback) => bufferWriter([4], [feedback]))
+    );
+    const buf = Buffer.concat([
+      constant,
+      bufferWriter([3], [writer.value]),
+      feedbacks
+    ]);
+    this.length = buf.length / 4;
+    return buf;
+  }
+};
+
+// ../rtp/src/rtcp/psfb/index.ts
+var log3 = debug("werift-rtp: /rtcp/psfb/index");
+var RtcpPayloadSpecificFeedback = class _RtcpPayloadSpecificFeedback {
+  static type = 206;
+  type = _RtcpPayloadSpecificFeedback.type;
+  feedback;
+  constructor(props = {}) {
+    Object.assign(this, props);
+  }
+  serialize() {
+    const payload = this.feedback.serialize();
+    return RtcpHeader.serialize(
+      this.type,
+      this.feedback.count,
+      payload,
+      this.feedback.length
+    );
+  }
+  static deSerialize(data, header) {
+    let feedback;
+    switch (header.count) {
+      case FullIntraRequest.count:
+        feedback = FullIntraRequest.deSerialize(data);
+        break;
+      case PictureLossIndication.count:
+        feedback = PictureLossIndication.deSerialize(data);
+        break;
+      case ReceiverEstimatedMaxBitrate.count:
+        feedback = ReceiverEstimatedMaxBitrate.deSerialize(data);
+        break;
+      default:
+        log3("unknown psfb packet", header.count);
+        break;
+    }
+    return new _RtcpPayloadSpecificFeedback({ feedback });
+  }
+};
+
 // ../rtp/src/rtcp/rr.ts
 var RtcpRrPacket = class _RtcpRrPacket {
   ssrc = 0;
@@ -2777,7 +3055,7 @@ var RtcpRrPacket = class _RtcpRrPacket {
       payload,
       ...this.reports.map((report) => report.serialize())
     ]);
-    return RtcpPacketConverter.serialize(
+    return RtcpHeader.serialize(
       _RtcpRrPacket.type,
       this.reports.length,
       payload,
@@ -2855,6 +3133,9 @@ var RtcpReceiverInfo = class _RtcpReceiverInfo {
   }
 };
 
+// ../rtp/src/rtcp/rtpfb/const.ts
+var RtcpTransportLayerFeedbackType = 205;
+
 // ../rtp/src/rtcp/rtpfb/nack.ts
 var GenericNack = class _GenericNack {
   static count = 1;
@@ -2874,7 +3155,7 @@ var GenericNack = class _GenericNack {
     Object.assign(this, props);
     if (!this.header) {
       this.header = new RtcpHeader({
-        type: RtcpTransportLayerFeedback.type,
+        type: RtcpTransportLayerFeedbackType,
         count: this.count,
         version: 2
       });
@@ -2926,7 +3207,7 @@ var GenericNack = class _GenericNack {
 };
 
 // ../rtp/src/rtcp/rtpfb/twcc.ts
-var log3 = debug("werift/rtp/rtcp/rtpfb/twcc");
+var log4 = debug("werift/rtp/rtcp/rtpfb/twcc");
 var TransportWideCC = class _TransportWideCC {
   static count = 15;
   count = _TransportWideCC.count;
@@ -3070,7 +3351,7 @@ var TransportWideCC = class _TransportWideCC {
         try {
           return delta.serialize();
         } catch (error) {
-          log3(error?.message);
+          log4(error?.message);
           return void 0;
         }
       }).filter((v) => v)
@@ -3147,19 +3428,19 @@ var StatusVectorChunk = class _StatusVectorChunk {
     const type = 1 /* TypeTCCStatusVectorChunk */;
     let symbolSize = getBit(data[0], 1, 1);
     const symbolList = [];
-    function range6(n, cb) {
+    function range(n, cb) {
       for (let i = 0; i < n; i++) {
         cb(i);
       }
     }
     switch (symbolSize) {
       case 0:
-        range6(6, (i) => symbolList.push(getBit(data[0], 2 + i, 1)));
-        range6(8, (i) => symbolList.push(getBit(data[1], i, 1)));
+        range(6, (i) => symbolList.push(getBit(data[0], 2 + i, 1)));
+        range(8, (i) => symbolList.push(getBit(data[1], i, 1)));
         break;
       case 1:
-        range6(3, (i) => symbolList.push(getBit(data[0], 2 + i * 2, 2)));
-        range6(4, (i) => symbolList.push(getBit(data[1], i * 2, 2)));
+        range(3, (i) => symbolList.push(getBit(data[0], 2 + i * 2, 2)));
+        range(4, (i) => symbolList.push(getBit(data[1], i * 2, 2)));
         break;
       default:
         symbolSize = (getBit(data[0], 2, 6) << 8) + data[1];
@@ -3253,9 +3534,9 @@ var PacketResult = class {
 };
 
 // ../rtp/src/rtcp/rtpfb/index.ts
-var log4 = debug("werift-rtp:packages/rtp/rtcp/rtpfb/index");
+var log5 = debug("werift-rtp:packages/rtp/rtcp/rtpfb/index");
 var RtcpTransportLayerFeedback = class _RtcpTransportLayerFeedback {
-  static type = 205;
+  static type = RtcpTransportLayerFeedbackType;
   type = _RtcpTransportLayerFeedback.type;
   feedback;
   header;
@@ -3276,7 +3557,7 @@ var RtcpTransportLayerFeedback = class _RtcpTransportLayerFeedback {
         feedback = TransportWideCC.deSerialize(data, header);
         break;
       default:
-        log4("unknown rtpfb packet", header.count);
+        log5("unknown rtpfb packet", header.count);
         break;
     }
     return new _RtcpTransportLayerFeedback({ feedback, header });
@@ -3300,7 +3581,7 @@ var RtcpSourceDescriptionPacket = class _RtcpSourceDescriptionPacket {
     let payload = Buffer.concat(this.chunks.map((chunk) => chunk.serialize()));
     while (payload.length % 4)
       payload = Buffer.concat([payload, Buffer.from([0])]);
-    return RtcpPacketConverter.serialize(
+    return RtcpHeader.serialize(
       this.type,
       this.chunks.length,
       payload,
@@ -3406,7 +3687,7 @@ var RtcpSrPacket = class _RtcpSrPacket {
       payload,
       ...this.reports.map((report) => report.serialize())
     ]);
-    return RtcpPacketConverter.serialize(
+    return RtcpHeader.serialize(
       _RtcpSrPacket.type,
       this.reports.length,
       payload,
@@ -3446,238 +3727,78 @@ var RtcpSenderInfo = class _RtcpSenderInfo {
     return bufferWriter(
       [8, 4, 4, 4],
       [this.ntpTimestamp, this.rtpTimestamp, this.packetCount, this.octetCount]
-    );
-  }
-  static deSerialize(data) {
-    const [ntpTimestamp, rtpTimestamp, packetCount, octetCount] = bufferReader(
-      data,
-      [8, 4, 4, 4]
-    );
-    return new _RtcpSenderInfo({
-      ntpTimestamp,
-      rtpTimestamp,
-      packetCount,
-      octetCount
-    });
-  }
-};
-var ntpTime2Sec = (ntp) => {
-  const [ntpSec, ntpMsec] = bufferReader(bufferWriter([8], [ntp]), [4, 4]);
-  return Number(`${ntpSec}.${ntpMsec}`);
-};
-
-// ../rtp/src/rtcp/rtcp.ts
-var log5 = debug("werift-rtp:packages/rtp/src/rtcp/rtcp.ts");
-var RtcpPacketConverter = class {
-  static serialize(type, count, payload, length) {
-    const header = new RtcpHeader({
-      type,
-      count,
-      version: 2,
-      length
-    });
-    const buf = header.serialize();
-    return Buffer.concat([buf, payload]);
-  }
-  static deSerialize(data) {
-    let pos = 0;
-    const packets = [];
-    while (pos < data.length) {
-      const header = RtcpHeader.deSerialize(
-        data.subarray(pos, pos + RTCP_HEADER_SIZE)
-      );
-      pos += RTCP_HEADER_SIZE;
-      let payload = data.subarray(pos);
-      pos += header.length * 4;
-      if (header.padding) {
-        payload = payload.subarray(0, payload.length - payload.subarray(-1)[0]);
-      }
-      try {
-        switch (header.type) {
-          case RtcpSrPacket.type:
-            packets.push(RtcpSrPacket.deSerialize(payload, header.count));
-            break;
-          case RtcpRrPacket.type:
-            packets.push(RtcpRrPacket.deSerialize(payload, header.count));
-            break;
-          case RtcpSourceDescriptionPacket.type:
-            packets.push(
-              RtcpSourceDescriptionPacket.deSerialize(payload, header)
-            );
-            break;
-          case RtcpTransportLayerFeedback.type:
-            packets.push(
-              RtcpTransportLayerFeedback.deSerialize(payload, header)
-            );
-            break;
-          case RtcpPayloadSpecificFeedback.type:
-            packets.push(
-              RtcpPayloadSpecificFeedback.deSerialize(payload, header)
-            );
-            break;
-          default:
-            break;
-        }
-      } catch (error) {
-        log5("deSerialize RTCP", error);
-      }
-    }
-    return packets;
-  }
-};
-function isRtcp(buf) {
-  return buf.length >= 2 && buf[1] >= 192 && buf[1] <= 208;
-}
-
-// ../rtp/src/rtcp/psfb/fullIntraRequest.ts
-var FullIntraRequest = class _FullIntraRequest {
-  static count = 4;
-  count = _FullIntraRequest.count;
-  senderSsrc;
-  mediaSsrc;
-  fir = [];
-  constructor(props = {}) {
-    Object.assign(this, props);
-  }
-  get length() {
-    return Math.floor(this.serialize().length / 4 - 1);
-  }
-  static deSerialize(data) {
-    const [senderSsrc, mediaSsrc] = bufferReader(data, [4, 4]);
-    const fir = [];
-    for (let i = 8; i < data.length; i += 8) {
-      fir.push({ ssrc: data.readUInt32BE(i), sequenceNumber: data[i + 4] });
-    }
-    return new _FullIntraRequest({ senderSsrc, mediaSsrc, fir });
-  }
-  serialize() {
-    const ssrcs = bufferWriter([4, 4], [this.senderSsrc, this.mediaSsrc]);
-    const fir = Buffer.alloc(this.fir.length * 8);
-    this.fir.forEach(({ ssrc, sequenceNumber }, i) => {
-      fir.writeUInt32BE(ssrc, i * 8);
-      fir[i * 8 + 4] = sequenceNumber;
-    });
-    return Buffer.concat([ssrcs, fir]);
-  }
-};
-
-// ../rtp/src/rtcp/psfb/pictureLossIndication.ts
-var PictureLossIndication = class _PictureLossIndication {
-  static count = 1;
-  count = _PictureLossIndication.count;
-  length = 2;
-  senderSsrc;
-  mediaSsrc;
-  constructor(props = {}) {
-    Object.assign(this, props);
-  }
-  static deSerialize(data) {
-    const [senderSsrc, mediaSsrc] = bufferReader(data, [4, 4]);
-    return new _PictureLossIndication({ senderSsrc, mediaSsrc });
-  }
-  serialize() {
-    return bufferWriter([4, 4], [this.senderSsrc, this.mediaSsrc]);
-  }
-};
-
-// ../rtp/src/rtcp/psfb/remb.ts
-var ReceiverEstimatedMaxBitrate = class _ReceiverEstimatedMaxBitrate {
-  static count = 15;
-  length;
-  count = _ReceiverEstimatedMaxBitrate.count;
-  senderSsrc;
-  mediaSsrc;
-  uniqueID = "REMB";
-  ssrcNum = 0;
-  brExp;
-  brMantissa;
-  bitrate;
-  ssrcFeedbacks = [];
-  constructor(props = {}) {
-    Object.assign(this, props);
-  }
-  static deSerialize(data) {
-    const [senderSsrc, mediaSsrc, uniqueID, ssrcNum, e_m] = bufferReader(
-      data,
-      [4, 4, 4, 1, 1]
-    );
-    const brExp = getBit(e_m, 0, 6);
-    const brMantissa = (getBit(e_m, 6, 2) << 16) + (data[14] << 8) + data[15];
-    const bitrate = brExp > 46 ? 18446744073709551615n : BigInt(brMantissa) << BigInt(brExp);
-    const ssrcFeedbacks = [];
-    for (let i = 16; i < data.length; i += 4) {
-      const feedback = data.slice(i).readUIntBE(0, 4);
-      ssrcFeedbacks.push(feedback);
-    }
-    return new _ReceiverEstimatedMaxBitrate({
-      senderSsrc,
-      mediaSsrc,
-      uniqueID: bufferWriter([4], [uniqueID]).toString(),
-      ssrcNum,
-      brExp,
-      brMantissa,
-      ssrcFeedbacks,
-      bitrate
-    });
-  }
-  serialize() {
-    const constant = Buffer.concat([
-      bufferWriter([4, 4], [this.senderSsrc, this.mediaSsrc]),
-      Buffer.from(this.uniqueID),
-      bufferWriter([1], [this.ssrcNum])
-    ]);
-    const writer = new BitWriter(24);
-    writer.set(6, 0, this.brExp).set(18, 6, this.brMantissa);
-    const feedbacks = Buffer.concat(
-      this.ssrcFeedbacks.map((feedback) => bufferWriter([4], [feedback]))
-    );
-    const buf = Buffer.concat([
-      constant,
-      bufferWriter([3], [writer.value]),
-      feedbacks
-    ]);
-    this.length = buf.length / 4;
-    return buf;
-  }
-};
-
-// ../rtp/src/rtcp/psfb/index.ts
-var log6 = debug("werift-rtp: /rtcp/psfb/index");
-var RtcpPayloadSpecificFeedback = class _RtcpPayloadSpecificFeedback {
-  static type = 206;
-  type = _RtcpPayloadSpecificFeedback.type;
-  feedback;
-  constructor(props = {}) {
-    Object.assign(this, props);
+    );
   }
-  serialize() {
-    const payload = this.feedback.serialize();
-    return RtcpPacketConverter.serialize(
-      this.type,
-      this.feedback.count,
-      payload,
-      this.feedback.length
+  static deSerialize(data) {
+    const [ntpTimestamp, rtpTimestamp, packetCount, octetCount] = bufferReader(
+      data,
+      [8, 4, 4, 4]
     );
+    return new _RtcpSenderInfo({
+      ntpTimestamp,
+      rtpTimestamp,
+      packetCount,
+      octetCount
+    });
   }
-  static deSerialize(data, header) {
-    let feedback;
-    switch (header.count) {
-      case FullIntraRequest.count:
-        feedback = FullIntraRequest.deSerialize(data);
-        break;
-      case PictureLossIndication.count:
-        feedback = PictureLossIndication.deSerialize(data);
-        break;
-      case ReceiverEstimatedMaxBitrate.count:
-        feedback = ReceiverEstimatedMaxBitrate.deSerialize(data);
-        break;
-      default:
-        log6("unknown psfb packet", header.count);
-        break;
+};
+var ntpTime2Sec = (ntp) => {
+  const [ntpSec, ntpMsec] = bufferReader(bufferWriter([8], [ntp]), [4, 4]);
+  return Number(`${ntpSec}.${ntpMsec}`);
+};
+
+// ../rtp/src/rtcp/rtcp.ts
+var log6 = debug("werift-rtp:packages/rtp/src/rtcp/rtcp.ts");
+var RtcpPacketConverter = class {
+  static deSerialize(data) {
+    let pos = 0;
+    const packets = [];
+    while (pos < data.length) {
+      const header = RtcpHeader.deSerialize(
+        data.subarray(pos, pos + RTCP_HEADER_SIZE)
+      );
+      pos += RTCP_HEADER_SIZE;
+      let payload = data.subarray(pos);
+      pos += header.length * 4;
+      if (header.padding) {
+        payload = payload.subarray(0, payload.length - payload.subarray(-1)[0]);
+      }
+      try {
+        switch (header.type) {
+          case RtcpSrPacket.type:
+            packets.push(RtcpSrPacket.deSerialize(payload, header.count));
+            break;
+          case RtcpRrPacket.type:
+            packets.push(RtcpRrPacket.deSerialize(payload, header.count));
+            break;
+          case RtcpSourceDescriptionPacket.type:
+            packets.push(
+              RtcpSourceDescriptionPacket.deSerialize(payload, header)
+            );
+            break;
+          case RtcpTransportLayerFeedback.type:
+            packets.push(
+              RtcpTransportLayerFeedback.deSerialize(payload, header)
+            );
+            break;
+          case RtcpPayloadSpecificFeedback.type:
+            packets.push(
+              RtcpPayloadSpecificFeedback.deSerialize(payload, header)
+            );
+            break;
+          default:
+            break;
+        }
+      } catch (error) {
+        log6("deSerialize RTCP", error);
+      }
     }
-    return new _RtcpPayloadSpecificFeedback({ feedback });
+    return packets;
   }
 };
+function isRtcp(buf) {
+  return buf.length >= 2 && buf[1] >= 192 && buf[1] <= 208;
+}
 
 // ../rtp/src/rtp/headerExtension.ts
 var RTP_EXTENSION_URI = {
@@ -4022,6 +4143,7 @@ var RtpHeader = class _RtpHeader {
       h.extensionLength = extensionLength;
       currOffset += 2;
       switch (h.extensionProfile) {
+        // RFC 8285 RTP One Byte Header Extension
         case ExtensionProfiles.OneByte:
           {
             const end = currOffset + extensionLength;
@@ -4045,6 +4167,7 @@ var RtpHeader = class _RtpHeader {
             }
           }
           break;
+        // RFC 8285 RTP Two Byte Header Extension
         case ExtensionProfiles.TwoByte:
           {
             const end = currOffset + extensionLength;
@@ -4589,7 +4712,7 @@ var Context = class {
     sessionSalt = Buffer.concat([sessionSalt, Buffer.from([0, 0])]);
     const block = new AES.AES(this.masterKey);
     sessionSalt = Buffer.from(block.encrypt(sessionSalt));
-    return sessionSalt.slice(0, 14);
+    return sessionSalt.subarray(0, 14);
   }
   generateSessionAuthTag(label) {
     const sessionAuthTag = Buffer.from(this.masterSalt);
@@ -4605,12 +4728,18 @@ var Context = class {
     for (let i = labelAndIndexOverKdr.length - 1, j = sessionAuthTag.length - 1; i >= 0; i--, j--) {
       sessionAuthTag[j] = sessionAuthTag[j] ^ labelAndIndexOverKdr[i];
     }
-    let firstRun = Buffer.concat([sessionAuthTag, Buffer.from([0, 0])]);
-    let secondRun = Buffer.concat([sessionAuthTag, Buffer.from([0, 1])]);
+    let firstRun = Buffer.concat([
+      sessionAuthTag,
+      Buffer.from([0, 0])
+    ]);
+    let secondRun = Buffer.concat([
+      sessionAuthTag,
+      Buffer.from([0, 1])
+    ]);
     const block = new AES.AES(this.masterKey);
     firstRun = Buffer.from(block.encrypt(firstRun));
     secondRun = Buffer.from(block.encrypt(secondRun));
-    return Buffer.concat([firstRun, secondRun.slice(0, 4)]);
+    return Buffer.concat([firstRun, secondRun.subarray(0, 4)]);
   }
   getSrtpSsrcState(ssrc) {
     let s = this.srtpSSRCStates[ssrc];
@@ -5023,7 +5152,7 @@ var DtxBase = class {
     this.ptime = ptime;
     this.dummyPacket = dummyPacket;
   }
-  id = randomUUID();
+  id = randomUUID().toString();
   previousTimestamp;
   fillCount = 0;
   internalStats = {};
@@ -5280,7 +5409,7 @@ var LipsyncBase = class {
     this.videoBuffer = [...new Array(this.bufferLength)].map(() => []);
     this.ptime = this.options.ptime ?? 20;
   }
-  id = randomUUID2();
+  id = randomUUID2().toString();
   bufferLength;
   /**ms */
   baseTime;
@@ -5395,10 +5524,10 @@ var LipsyncBase = class {
     if (frame.time < this.lastCommittedTime) {
       return;
     }
-    const now2 = Date.now();
+    const now = Date.now();
     const gap = 5e3;
     const lastCommittedElapsed = frame.time - this.lastCommittedTime;
-    const lastFrameReceivedElapsed = now2 - this.lastFrameReceivedAt;
+    const lastFrameReceivedElapsed = now - this.lastFrameReceivedAt;
     if (gap < lastFrameReceivedElapsed && lastCommittedElapsed < gap) {
       this.internalStats["invalidFrameTime"] = {
         count: (this.internalStats["invalidFrameTime"]?.count ?? 0) + 1,
@@ -5408,7 +5537,7 @@ var LipsyncBase = class {
       };
       return;
     }
-    this.lastFrameReceivedAt = now2;
+    this.lastFrameReceivedAt = now;
     const elapsed = frame.time - this.baseTime;
     const index = int(elapsed / this.bufferDuration) % this.bufferLength;
     buffer2[index].push({
@@ -5417,9 +5546,9 @@ var LipsyncBase = class {
     });
     const diff = frame.time - this.lastExecutionTime;
     if (diff >= this.interval) {
-      const times2 = int(diff / this.bufferDuration) - 1;
+      const times = int(diff / this.bufferDuration) - 1;
       this.lastExecutionTime = this.currentTimestamp;
-      for (let i = 0; i < times2; i++) {
+      for (let i = 0; i < times; i++) {
         this.executeTask();
         this.lastExecutionTime += this.bufferDuration;
       }
@@ -5508,7 +5637,9 @@ var MP4Base = class {
       if (!this.container.audioTrack) {
         this.container.write({
           codec: track.codec,
-          description: buffer2ArrayBuffer(OpusRtpPayload.createCodecPrivate()),
+          description: buffer2ArrayBuffer(
+            OpusRtpPayload.createCodecPrivate()
+          ),
           numberOfChannels: 2,
           sampleRate: track.clockRate,
           track: "audio"
@@ -5644,7 +5775,7 @@ var MuteHandlerBase = class {
     this.bufferLength = this.props.bufferLength * 2;
     this.buffer = [...new Array(this.bufferLength)].map(() => []);
   }
-  id = randomUUID3();
+  id = randomUUID3().toString();
   buffer;
   index = 0;
   ended = false;
@@ -5713,10 +5844,10 @@ var MuteHandlerBase = class {
     if (frame.time < this.lastCommittedTime) {
       return [];
     }
-    const now2 = Date.now();
+    const now = Date.now();
     const gap = 5e3;
     const lastCommittedElapsed = frame.time - this.lastCommittedTime;
-    const lastFrameReceivedElapsed = now2 - this.lastFrameReceivedAt;
+    const lastFrameReceivedElapsed = now - this.lastFrameReceivedAt;
     if (gap < lastFrameReceivedElapsed && lastCommittedElapsed < gap) {
       this.internalStats["invalidFrameTime"] = {
         count: (this.internalStats["invalidFrameTime"]?.count ?? 0) + 1,
@@ -5726,15 +5857,15 @@ var MuteHandlerBase = class {
       };
       return [];
     }
-    this.lastFrameReceivedAt = now2;
+    this.lastFrameReceivedAt = now;
     const elapsed = frame.time - this.baseTime;
     const index = int(elapsed / this.bufferDuration) % this.bufferLength;
     this.buffer[index].push(frame);
     const lastExecution = frame.time - this.lastExecutionTime;
     if (lastExecution >= this.interval) {
-      const times2 = int(lastExecution / this.bufferDuration) - 1;
+      const times = int(lastExecution / this.bufferDuration) - 1;
       this.lastExecutionTime = this.currentTimestamp;
-      for (let i = 0; i < times2; i++) {
+      for (let i = 0; i < times; i++) {
         this.executeTask();
         this.lastExecutionTime += this.bufferDuration;
       }
@@ -6210,7 +6341,7 @@ var NtpTimeBase = class {
   constructor(clockRate) {
     this.clockRate = clockRate;
   }
-  id = randomUUID4();
+  id = randomUUID4().toString();
   baseNtpTimestamp;
   baseRtpTimestamp;
   latestNtpTimestamp;
@@ -6601,16 +6732,15 @@ var WebmStream = class extends WebmBase {
 };
 
 // src/nonstandard/navigator.ts
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 import { createSocket as createSocket3 } from "dgram";
-import { jspack as jspack11 } from "@shinyoshiaki/jspack";
+import { jspack as jspack8 } from "@shinyoshiaki/jspack";
 
 // ../dtls/src/context/cipher.ts
-import nodeCrypto, { createSign } from "crypto";
+import { createSign, randomBytes as randomBytes3, webcrypto } from "crypto";
 import { Certificate, PrivateKey } from "@fidm/x509";
 import * as x509 from "@peculiar/x509";
-import { decode, encode, types as types2 } from "@shinyoshiaki/binary-data";
-import { addYears } from "date-fns";
+import { encode, types } from "@shinyoshiaki/binary-data";
 
 // ../dtls/src/cipher/const.ts
 var SignatureAlgorithm = {
@@ -6789,22 +6919,8 @@ var AbstractCipher = class {
   }
 };
 
-// ../dtls/src/handshake/binary.ts
-import { types } from "@shinyoshiaki/binary-data";
-var { uint16be, uint24be, buffer, array, uint8, string: string2 } = types;
-var Extension = {
-  type: uint16be,
-  data: buffer(uint16be)
-};
-var ExtensionList = array(Extension, uint16be, "bytes");
-var ASN11Cert = buffer(uint24be);
-var ClientCertificateType = uint8;
-var DistinguishedName = string2(uint16be);
-var SignatureHashAlgorithm = { hash: uint8, signature: uint8 };
-var ProtocolVersion = { major: uint8, minor: uint8 };
-
 // ../dtls/src/context/cipher.ts
-var crypto = nodeCrypto.webcrypto;
+var crypto = webcrypto;
 x509.cryptoProvider.set(crypto);
 var CipherContext = class {
   constructor(sessionType, certPem, keyPem, signatureHashAlgorithm) {
@@ -6880,10 +6996,10 @@ var CipherContext = class {
       "verify"
     ]);
     const cert = await x509.X509CertificateGenerator.createSelfSigned({
-      serialNumber: nodeCrypto.randomBytes(8).toString("hex"),
+      serialNumber: randomBytes3(8).toString("hex"),
       name: "C=AU, ST=Some-State, O=Internet Widgits Pty Ltd",
       notBefore: /* @__PURE__ */ new Date(),
-      notAfter: addYears(Date.now(), 10),
+      notAfter: new Date(Date.now() + 10 * 365 * 24 * 60 * 60 * 1e3),
       signingAlgorithm: alg,
       keys
     });
@@ -6896,12 +7012,10 @@ var CipherContext = class {
   };
   encryptPacket(pkt) {
     const header = pkt.recordLayerHeader;
+    const version = header.protocolVersion.major << 8 | header.protocolVersion.minor;
     const enc = this.cipher.encrypt(this.sessionType, pkt.fragment, {
       type: header.contentType,
-      version: decode(
-        Buffer.from(encode(header.protocolVersion, ProtocolVersion).slice()),
-        { version: types2.uint16be }
-      ).version,
+      version,
       epoch: header.epoch,
       sequenceNumber: header.sequenceNumber
     });
@@ -6911,12 +7025,10 @@ var CipherContext = class {
   }
   decryptPacket(pkt) {
     const header = pkt.recordLayerHeader;
+    const version = header.protocolVersion.major << 8 | header.protocolVersion.minor;
     const dec = this.cipher.decrypt(this.sessionType, pkt.fragment, {
       type: header.contentType,
-      version: decode(
-        Buffer.from(encode(header.protocolVersion, ProtocolVersion).slice()),
-        { version: types2.uint16be }
-      ).version,
+      version,
       epoch: header.epoch,
       sequenceNumber: header.sequenceNumber
     });
@@ -6960,7 +7072,7 @@ var CipherContext = class {
           curve: namedCurve,
           len: publicKey.length
         },
-        { type: types2.uint8, curve: types2.uint16be, len: types2.uint8 }
+        { type: types.uint8, curve: types.uint16be, len: types.uint8 }
       ).slice()
     );
     return Buffer.concat([clientRandom, serverRandom, serverParams, publicKey]);
@@ -6978,10 +7090,10 @@ var SrtpContext2 = class {
 };
 
 // ../dtls/src/handshake/message/client/hello.ts
-import { decode as decode4, encode as encode4, types as types5 } from "@shinyoshiaki/binary-data";
+import { decode as decode3, encode as encode4, types as types5 } from "@shinyoshiaki/binary-data";
 
 // ../dtls/src/record/message/fragment.ts
-import { decode as decode2, encode as encode2, types as types3 } from "@shinyoshiaki/binary-data";
+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");
@@ -7006,12 +7118,12 @@ var FragmentedHandshake = class _FragmentedHandshake {
     this.fragment = fragment;
   }
   static spec = {
-    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)
+    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)
   };
   get summary() {
     return getObjectSummary(this);
@@ -7028,7 +7140,7 @@ var FragmentedHandshake = class _FragmentedHandshake {
   }
   static deSerialize(buf) {
     return new _FragmentedHandshake(
-      ...Object.values(decode2(buf, _FragmentedHandshake.spec))
+      ...Object.values(decode(buf, _FragmentedHandshake.spec))
     );
   }
   serialize() {
@@ -7105,11 +7217,25 @@ 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 Extension = {
+  type: uint16be,
+  data: buffer(uint16be)
+};
+var ExtensionList = array(Extension, uint16be, "bytes");
+var ASN11Cert = buffer(uint24be);
+var ClientCertificateType = uint8;
+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 decode3, encode as encode3, types as types4 } from "@shinyoshiaki/binary-data";
+import { randomBytes as randomBytes4 } from "crypto";
+import { decode as decode2, encode as encode3, types as types4 } from "@shinyoshiaki/binary-data";
 var DtlsRandom = class _DtlsRandom {
-  constructor(gmt_unix_time = Math.floor(Date.now() / 1e3), random_bytes = randomBytes3(28)) {
+  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;
   }
@@ -7119,7 +7245,7 @@ var DtlsRandom = class _DtlsRandom {
   };
   static deSerialize(buf) {
     return new _DtlsRandom(
-      ...Object.values(decode3(buf, _DtlsRandom.spec))
+      ...Object.values(decode2(buf, _DtlsRandom.spec))
     );
   }
   static from(spec) {
@@ -7166,7 +7292,7 @@ var ClientHello = class _ClientHello {
   }
   static deSerialize(buf) {
     return new _ClientHello(
-      ...Object.values(decode4(buf, _ClientHello.spec))
+      ...Object.values(decode3(buf, _ClientHello.spec))
     );
   }
   serialize() {
@@ -7186,45 +7312,8 @@ var ClientHello = class _ClientHello {
   }
 };
 
-// ../dtls/src/record/message/plaintext.ts
-import { decode as decode6, encode as encode6, types as types7 } from "@shinyoshiaki/binary-data";
-
 // ../dtls/src/record/message/header.ts
-import { decode as decode5, encode as encode5, types as types6 } from "@shinyoshiaki/binary-data";
-var DtlsPlaintextHeader = class _DtlsPlaintextHeader {
-  constructor(contentType, protocolVersion, epoch, sequenceNumber, contentLen) {
-    this.contentType = contentType;
-    this.protocolVersion = protocolVersion;
-    this.epoch = epoch;
-    this.sequenceNumber = sequenceNumber;
-    this.contentLen = contentLen;
-  }
-  static spec = {
-    contentType: types6.uint8,
-    protocolVersion: ProtocolVersion,
-    epoch: types6.uint16be,
-    sequenceNumber: types6.uint48be,
-    contentLen: types6.uint16be
-  };
-  static createEmpty() {
-    return new _DtlsPlaintextHeader(
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      void 0
-    );
-  }
-  static deSerialize(buf) {
-    return new _DtlsPlaintextHeader(
-      ...Object.values(decode5(buf, _DtlsPlaintextHeader.spec))
-    );
-  }
-  serialize() {
-    const res = encode5(this, _DtlsPlaintextHeader.spec).slice();
-    return Buffer.from(res);
-  }
-};
+import { decode as decode4, encode as encode5, types as types6 } from "@shinyoshiaki/binary-data";
 var MACHeader = class _MACHeader {
   constructor(epoch, sequenceNumber, contentType, protocolVersion, contentLen) {
     this.epoch = epoch;
@@ -7251,7 +7340,7 @@ var MACHeader = class _MACHeader {
   }
   static deSerialize(buf) {
     return new _MACHeader(
-      ...Object.values(decode5(buf, _MACHeader.spec))
+      ...Object.values(decode4(buf, _MACHeader.spec))
     );
   }
   serialize() {
@@ -7260,48 +7349,6 @@ var MACHeader = class _MACHeader {
   }
 };
 
-// ../dtls/src/record/message/plaintext.ts
-var DtlsPlaintext = class _DtlsPlaintext {
-  constructor(recordLayerHeader, fragment) {
-    this.recordLayerHeader = recordLayerHeader;
-    this.fragment = fragment;
-  }
-  static spec = {
-    recordLayerHeader: DtlsPlaintextHeader.spec,
-    fragment: types7.buffer(
-      (context) => context.current.recordLayerHeader.contentLen
-    )
-  };
-  get summary() {
-    return {
-      header: this.recordLayerHeader,
-      fragment: dumpBuffer2(this.fragment)
-    };
-  }
-  static createEmpty() {
-    return new _DtlsPlaintext(void 0, void 0);
-  }
-  static deSerialize(buf) {
-    const r = new _DtlsPlaintext(
-      ...Object.values(decode6(buf, _DtlsPlaintext.spec))
-    );
-    return r;
-  }
-  serialize() {
-    const res = encode6(this, _DtlsPlaintext.spec).slice();
-    return Buffer.from(res);
-  }
-  computeMACHeader() {
-    return new MACHeader(
-      this.recordLayerHeader.epoch,
-      this.recordLayerHeader.sequenceNumber,
-      this.recordLayerHeader.contentType,
-      this.recordLayerHeader.protocolVersion,
-      this.recordLayerHeader.contentLen
-    ).serialize();
-  }
-};
-
 // ../dtls/src/flight/flight.ts
 var warn = debug("werift-dtls : packages/dtls/src/flight/flight.ts : warn");
 var err = debug("werift-dtls : packages/dtls/src/flight/flight.ts : err");
@@ -7383,18 +7430,7 @@ function createECDHEPSKKeyExchange() {
 }
 
 // ../dtls/src/cipher/suites/aead.ts
-import * as crypto2 from "crypto";
-import { createDecode as createDecode2, encode as encode7, types as types8 } from "@shinyoshiaki/binary-data";
-var { uint8: uint82, uint16be: uint16be2, uint48be } = types8;
-var ContentType2 = uint82;
-var ProtocolVersion2 = uint16be2;
-var AEADAdditionalData = {
-  epoch: uint16be2,
-  sequence: uint48be,
-  type: ContentType2,
-  version: ProtocolVersion2,
-  length: uint16be2
-};
+import { createCipheriv as createCipheriv4, createDecipheriv as createDecipheriv3 } from "crypto";
 var err2 = debug(
   "werift-dtls : packages/dtls/src/cipher/suites/aead.ts : err"
 );
@@ -7441,22 +7477,10 @@ var AEADCipher = class extends AbstractCipher {
     iv.writeUInt16BE(header.epoch, this.nonceImplicitLength);
     iv.writeUIntBE(header.sequenceNumber, this.nonceImplicitLength + 2, 6);
     const explicitNonce = iv.slice(this.nonceImplicitLength);
-    const additionalData = {
-      epoch: header.epoch,
-      sequence: header.sequenceNumber,
-      type: header.type,
-      version: header.version,
-      length: data.length
-    };
-    const additionalBuffer = encode7(additionalData, AEADAdditionalData).slice();
-    const cipher = crypto2.createCipheriv(
-      this.blockAlgorithm,
-      writeKey,
-      iv,
-      {
-        authTagLength: this.authTagLength
-      }
-    );
+    const additionalBuffer = this.encodeAdditionalBuffer(header, data.length);
+    const cipher = createCipheriv4(this.blockAlgorithm, writeKey, iv, {
+      authTagLength: this.authTagLength
+    });
     cipher.setAAD(additionalBuffer, {
       plaintextLength: data.length
     });
@@ -7465,6 +7489,15 @@ var AEADCipher = class extends AbstractCipher {
     const authTag = cipher.getAuthTag();
     return Buffer.concat([explicitNonce, headPart, finalPart, authTag]);
   }
+  encodeAdditionalBuffer(header, dataLength) {
+    const additionalBuffer = Buffer.alloc(13);
+    additionalBuffer.writeUInt16BE(header.epoch, 0);
+    additionalBuffer.writeUintBE(header.sequenceNumber, 2, 6);
+    additionalBuffer.writeUInt8(header.type, 8);
+    additionalBuffer.writeUInt16BE(header.version, 9);
+    additionalBuffer.writeUInt16BE(dataLength, 11);
+    return additionalBuffer;
+  }
   /**
    * Decrypt message.
    */
@@ -7473,27 +7506,20 @@ var AEADCipher = class extends AbstractCipher {
     const iv = isClient ? this.serverNonce : this.clientNonce;
     const writeKey = isClient ? this.serverWriteKey : this.clientWriteKey;
     if (!iv || !writeKey) throw new Error();
-    const final = createDecode2(data);
-    const explicitNonce = final.readBuffer(this.nonceExplicitLength);
+    const explicitNonce = data.subarray(0, this.nonceExplicitLength);
     explicitNonce.copy(iv, this.nonceImplicitLength);
-    const encrypted = final.readBuffer(final.length - this.authTagLength);
-    const authTag = final.readBuffer(this.authTagLength);
-    const additionalData = {
-      epoch: header.epoch,
-      sequence: header.sequenceNumber,
-      type: header.type,
-      version: header.version,
-      length: encrypted.length
-    };
-    const additionalBuffer = encode7(additionalData, AEADAdditionalData).slice();
-    const decipher = crypto2.createDecipheriv(
-      this.blockAlgorithm,
-      writeKey,
-      iv,
-      {
-        authTagLength: this.authTagLength
-      }
+    const encrypted = data.subarray(
+      this.nonceExplicitLength,
+      data.length - this.authTagLength
+    );
+    const authTag = data.subarray(data.length - this.authTagLength);
+    const additionalBuffer = this.encodeAdditionalBuffer(
+      header,
+      encrypted.length
     );
+    const decipher = createDecipheriv3(this.blockAlgorithm, writeKey, iv, {
+      authTagLength: this.authTagLength
+    });
     decipher.setAuthTag(authTag);
     decipher.setAAD(additionalBuffer, {
       plaintextLength: encrypted.length
@@ -7710,12 +7736,12 @@ var ExtendedMasterSecret = class {
 };
 
 // ../dtls/src/handshake/extensions/renegotiationIndication.ts
-import { decode as decode7, encode as encode8, types as types9 } from "@shinyoshiaki/binary-data";
+import { decode as decode5, encode as encode6, types as types7 } from "@shinyoshiaki/binary-data";
 var RenegotiationIndication = class _RenegotiationIndication {
   static type = 65281;
   static spec = {
-    type: types9.uint16be,
-    data: types9.uint8
+    type: types7.uint16be,
+    data: types7.uint8
   };
   type = _RenegotiationIndication.type;
   data = 0;
@@ -7728,11 +7754,11 @@ var RenegotiationIndication = class _RenegotiationIndication {
   }
   static deSerialize(buf) {
     return new _RenegotiationIndication(
-      decode7(buf, _RenegotiationIndication.spec)
+      decode5(buf, _RenegotiationIndication.spec)
     );
   }
   serialize() {
-    const res = encode8(this, _RenegotiationIndication.spec).slice();
+    const res = encode6(this, _RenegotiationIndication.spec).slice();
     return Buffer.from(res);
   }
   get extension() {
@@ -7744,14 +7770,13 @@ var RenegotiationIndication = class _RenegotiationIndication {
 };
 
 // ../dtls/src/handshake/extensions/useSrtp.ts
-import { decode as decode8, encode as encode9, types as types10 } from "@shinyoshiaki/binary-data";
-import times from "lodash/times.js";
+import { decode as decode6, encode as encode7, types as types8 } from "@shinyoshiaki/binary-data";
 var UseSRTP = class _UseSRTP {
   static type = 14;
   // 9.  IANA Considerations
   static spec = {
-    type: types10.uint16be,
-    data: types10.buffer(types10.uint16be)
+    type: types8.uint16be,
+    data: types8.buffer(types8.uint16be)
   };
   type = _UseSRTP.type;
   data = Buffer.from([]);
@@ -7768,11 +7793,12 @@ var UseSRTP = class _UseSRTP {
     return v;
   }
   static deSerialize(buf) {
-    const useSrtp = new _UseSRTP(decode8(buf, _UseSRTP.spec));
+    const useSrtp = new _UseSRTP(decode6(buf, _UseSRTP.spec));
     const profileLength = useSrtp.data.readUInt16BE();
-    const profiles = times(profileLength / 2).map((i) => {
-      return useSrtp.data.readUInt16BE(i * 2 + 2);
-    });
+    const profiles = new Array(profileLength / 2);
+    for (let i = 0; i < profiles.length; i++) {
+      profiles[i] = useSrtp.data.readUInt16BE(i * 2 + 2);
+    }
     useSrtp.profiles = profiles;
     useSrtp.mki = useSrtp.data.slice(profileLength + 2);
     return useSrtp;
@@ -7790,7 +7816,7 @@ var UseSRTP = class _UseSRTP {
       this.mki
     ]);
     this.data = data;
-    const res = encode9(this, _UseSRTP.spec).slice();
+    const res = encode7(this, _UseSRTP.spec).slice();
     return Buffer.from(res);
   }
   static fromData(buf) {
@@ -7808,7 +7834,7 @@ var UseSRTP = class _UseSRTP {
 };
 
 // ../dtls/src/handshake/message/certificate.ts
-import { decode as decode9, encode as encode10, types as types11 } from "@shinyoshiaki/binary-data";
+import { decode as decode7, encode as encode8, types as types9 } from "@shinyoshiaki/binary-data";
 var Certificate2 = class _Certificate {
   constructor(certificateList) {
     this.certificateList = certificateList;
@@ -7816,18 +7842,18 @@ var Certificate2 = class _Certificate {
   msgType = 11 /* certificate_11 */;
   messageSeq;
   static spec = {
-    certificateList: types11.array(ASN11Cert, types11.uint24be, "bytes")
+    certificateList: types9.array(ASN11Cert, types9.uint24be, "bytes")
   };
   static createEmpty() {
     return new _Certificate(void 0);
   }
   static deSerialize(buf) {
     return new _Certificate(
-      ...Object.values(decode9(buf, _Certificate.spec))
+      ...Object.values(decode7(buf, _Certificate.spec))
     );
   }
   serialize() {
-    const res = encode10(this, _Certificate.spec).slice();
+    const res = encode8(this, _Certificate.spec).slice();
     return Buffer.from(res);
   }
   toFragment() {
@@ -7844,30 +7870,30 @@ var Certificate2 = class _Certificate {
 };
 
 // ../dtls/src/handshake/message/changeCipherSpec.ts
-import { decode as decode10, encode as encode11, types as types12 } from "@shinyoshiaki/binary-data";
+import { decode as decode8, encode as encode9, types as types10 } from "@shinyoshiaki/binary-data";
 var ChangeCipherSpec = class _ChangeCipherSpec {
   constructor(type = 1) {
     this.type = type;
   }
   static spec = {
-    type: types12.uint8
+    type: types10.uint8
   };
   static createEmpty() {
     return new _ChangeCipherSpec();
   }
   static deSerialize(buf) {
     return new _ChangeCipherSpec(
-      ...Object.values(decode10(buf, _ChangeCipherSpec.spec))
+      ...Object.values(decode8(buf, _ChangeCipherSpec.spec))
     );
   }
   serialize() {
-    const res = encode11(this, _ChangeCipherSpec.spec).slice();
+    const res = encode9(this, _ChangeCipherSpec.spec).slice();
     return Buffer.from(res);
   }
 };
 
 // ../dtls/src/handshake/message/client/certificateVerify.ts
-import { decode as decode11, encode as encode12, types as types13 } from "@shinyoshiaki/binary-data";
+import { decode as decode9, encode as encode10, types as types11 } from "@shinyoshiaki/binary-data";
 var CertificateVerify = class _CertificateVerify {
   constructor(algorithm, signature) {
     this.algorithm = algorithm;
@@ -7876,20 +7902,20 @@ var CertificateVerify = class _CertificateVerify {
   msgType = 15 /* certificate_verify_15 */;
   messageSeq;
   static spec = {
-    algorithm: types13.uint16be,
-    signature: types13.buffer(types13.uint16be)
+    algorithm: types11.uint16be,
+    signature: types11.buffer(types11.uint16be)
   };
   static createEmpty() {
     return new _CertificateVerify(void 0, void 0);
   }
   static deSerialize(buf) {
-    const res = decode11(buf, _CertificateVerify.spec);
+    const res = decode9(buf, _CertificateVerify.spec);
     return new _CertificateVerify(
       ...Object.values(res)
     );
   }
   serialize() {
-    const res = encode12(this, _CertificateVerify.spec).slice();
+    const res = encode10(this, _CertificateVerify.spec).slice();
     return Buffer.from(res);
   }
   toFragment() {
@@ -7906,7 +7932,7 @@ var CertificateVerify = class _CertificateVerify {
 };
 
 // ../dtls/src/handshake/message/client/keyExchange.ts
-import { decode as decode12, encode as encode13, types as types14 } from "@shinyoshiaki/binary-data";
+import { decode as decode10, encode as encode11, types as types12 } from "@shinyoshiaki/binary-data";
 var ClientKeyExchange = class _ClientKeyExchange {
   constructor(publicKey) {
     this.publicKey = publicKey;
@@ -7914,19 +7940,19 @@ var ClientKeyExchange = class _ClientKeyExchange {
   msgType = 16 /* client_key_exchange_16 */;
   messageSeq;
   static spec = {
-    publicKey: types14.buffer(types14.uint8)
+    publicKey: types12.buffer(types12.uint8)
   };
   static createEmpty() {
     return new _ClientKeyExchange(void 0);
   }
   static deSerialize(buf) {
-    const res = decode12(buf, _ClientKeyExchange.spec);
+    const res = decode10(buf, _ClientKeyExchange.spec);
     return new _ClientKeyExchange(
       ...Object.values(res)
     );
   }
   serialize() {
-    const res = encode13(this, _ClientKeyExchange.spec).slice();
+    const res = encode11(this, _ClientKeyExchange.spec).slice();
     return Buffer.from(res);
   }
   toFragment() {
@@ -7943,7 +7969,7 @@ var ClientKeyExchange = class _ClientKeyExchange {
 };
 
 // ../dtls/src/handshake/message/server/certificateRequest.ts
-import { decode as decode13, encode as encode14, types as types15 } from "@shinyoshiaki/binary-data";
+import { decode as decode11, encode as encode12, types as types13 } from "@shinyoshiaki/binary-data";
 var ServerCertificateRequest = class _ServerCertificateRequest {
   constructor(certificateTypes2, signatures2, authorities) {
     this.certificateTypes = certificateTypes2;
@@ -7953,9 +7979,9 @@ var ServerCertificateRequest = class _ServerCertificateRequest {
   msgType = 13 /* certificate_request_13 */;
   messageSeq;
   static spec = {
-    certificateTypes: types15.array(ClientCertificateType, types15.uint8, "bytes"),
-    signatures: types15.array(SignatureHashAlgorithm, types15.uint16be, "bytes"),
-    authorities: types15.array(DistinguishedName, types15.uint16be, "bytes")
+    certificateTypes: types13.array(ClientCertificateType, types13.uint8, "bytes"),
+    signatures: types13.array(SignatureHashAlgorithm, types13.uint16be, "bytes"),
+    authorities: types13.array(DistinguishedName, types13.uint16be, "bytes")
   };
   static createEmpty() {
     return new _ServerCertificateRequest(
@@ -7966,11 +7992,11 @@ var ServerCertificateRequest = class _ServerCertificateRequest {
   }
   static deSerialize(buf) {
     return new _ServerCertificateRequest(
-      ...Object.values(decode13(buf, _ServerCertificateRequest.spec))
+      ...Object.values(decode11(buf, _ServerCertificateRequest.spec))
     );
   }
   serialize() {
-    const res = encode14(this, _ServerCertificateRequest.spec).slice();
+    const res = encode12(this, _ServerCertificateRequest.spec).slice();
     return Buffer.from(res);
   }
   toFragment() {
@@ -7987,7 +8013,7 @@ var ServerCertificateRequest = class _ServerCertificateRequest {
 };
 
 // ../dtls/src/handshake/message/server/hello.ts
-import { decode as decode14, encode as encode15, types as types16 } from "@shinyoshiaki/binary-data";
+import { decode as decode12, encode as encode13, types as types14 } from "@shinyoshiaki/binary-data";
 var ServerHello = class _ServerHello {
   constructor(serverVersion, random, sessionId, cipherSuite, compressionMethod, extensions) {
     this.serverVersion = serverVersion;
@@ -8002,9 +8028,9 @@ var ServerHello = class _ServerHello {
   static spec = {
     serverVersion: ProtocolVersion,
     random: DtlsRandom.spec,
-    sessionId: types16.buffer(types16.uint8),
-    cipherSuite: types16.uint16be,
-    compressionMethod: types16.uint8
+    sessionId: types14.buffer(types14.uint8),
+    cipherSuite: types14.uint16be,
+    compressionMethod: types14.uint8
   };
   static createEmpty() {
     return new _ServerHello(
@@ -8017,7 +8043,7 @@ var ServerHello = class _ServerHello {
     );
   }
   static deSerialize(buf) {
-    const res = decode14(buf, _ServerHello.spec);
+    const res = decode12(buf, _ServerHello.spec);
     const cls = new _ServerHello(
       ...Object.values(res)
     );
@@ -8025,14 +8051,14 @@ var ServerHello = class _ServerHello {
     if (expect.length < buf.length) {
       return new _ServerHello(
         ...Object.values(
-          decode14(buf, { ..._ServerHello.spec, extensions: ExtensionList })
+          decode12(buf, { ..._ServerHello.spec, extensions: ExtensionList })
         )
       );
     }
     return cls;
   }
   serialize() {
-    const res = this.extensions === void 0 ? encode15(this, _ServerHello.spec).slice() : encode15(this, {
+    const res = this.extensions === void 0 ? encode13(this, _ServerHello.spec).slice() : encode13(this, {
       ..._ServerHello.spec,
       extensions: ExtensionList
     }).slice();
@@ -8052,15 +8078,15 @@ var ServerHello = class _ServerHello {
 };
 
 // ../dtls/src/handshake/message/server/helloDone.ts
-import { decode as decode15, encode as encode16 } from "@shinyoshiaki/binary-data";
+import { decode as decode13, encode as encode14 } from "@shinyoshiaki/binary-data";
 
 // ../dtls/src/handshake/message/server/keyExchange.ts
-import { decode as decode16, types as types17 } from "@shinyoshiaki/binary-data";
+import { decode as decode14, types as types15 } from "@shinyoshiaki/binary-data";
 
 // ../dtls/src/util/binary.ts
-import { encode as encode17 } from "@shinyoshiaki/binary-data";
+import { encode as encode15 } from "@shinyoshiaki/binary-data";
 function encodeBuffer(obj, spec) {
-  return Buffer.from(encode17(obj, spec).slice());
+  return Buffer.from(encode15(obj, spec).slice());
 }
 
 // ../dtls/src/handshake/message/server/keyExchange.ts
@@ -8078,14 +8104,14 @@ var ServerKeyExchange = class _ServerKeyExchange {
   msgType = 12 /* server_key_exchange_12 */;
   messageSeq;
   static spec = {
-    ellipticCurveType: types17.uint8,
-    namedCurve: types17.uint16be,
-    publicKeyLength: types17.uint8,
-    publicKey: types17.buffer((ctx) => ctx.current.publicKeyLength),
-    hashAlgorithm: types17.uint8,
-    signatureAlgorithm: types17.uint8,
-    signatureLength: types17.uint16be,
-    signature: types17.buffer((ctx) => ctx.current.signatureLength)
+    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)
   };
   static createEmpty() {
     return new _ServerKeyExchange(
@@ -8100,7 +8126,7 @@ var ServerKeyExchange = class _ServerKeyExchange {
     );
   }
   static deSerialize(buf) {
-    const res = decode16(buf, _ServerKeyExchange.spec);
+    const res = decode14(buf, _ServerKeyExchange.spec);
     return new _ServerKeyExchange(
       ...Object.values(res)
     );
@@ -8181,7 +8207,7 @@ handlers[14 /* server_hello_done_14 */] = ({ dtls }) => (msg) => {
 };
 
 // ../dtls/src/handshake/message/server/helloVerifyRequest.ts
-import { decode as decode17, encode as encode18, types as types18 } from "@shinyoshiaki/binary-data";
+import { decode as decode15, encode as encode16, types as types16 } from "@shinyoshiaki/binary-data";
 var ServerHelloVerifyRequest = class _ServerHelloVerifyRequest {
   constructor(serverVersion, cookie) {
     this.serverVersion = serverVersion;
@@ -8191,18 +8217,18 @@ var ServerHelloVerifyRequest = class _ServerHelloVerifyRequest {
   messageSeq;
   static spec = {
     serverVersion: ProtocolVersion,
-    cookie: types18.buffer(types18.uint8)
+    cookie: types16.buffer(types16.uint8)
   };
   static createEmpty() {
     return new _ServerHelloVerifyRequest(void 0, void 0);
   }
   static deSerialize(buf) {
     return new _ServerHelloVerifyRequest(
-      ...Object.values(decode17(buf, _ServerHelloVerifyRequest.spec))
+      ...Object.values(decode15(buf, _ServerHelloVerifyRequest.spec))
     );
   }
   serialize() {
-    const res = encode18(this, _ServerHelloVerifyRequest.spec).slice();
+    const res = encode16(this, _ServerHelloVerifyRequest.spec).slice();
     return Buffer.from(res);
   }
   get version() {
@@ -8225,18 +8251,18 @@ var ServerHelloVerifyRequest = class _ServerHelloVerifyRequest {
 };
 
 // ../dtls/src/socket.ts
-import { decode as decode21, types as types22 } from "@shinyoshiaki/binary-data";
+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 decode18, encode as encode19, types as types19 } from "@shinyoshiaki/binary-data";
+import { decode as decode16, encode as encode17, types as types17 } from "@shinyoshiaki/binary-data";
 var EllipticCurves = class _EllipticCurves {
   static type = 10;
   static spec = {
-    type: types19.uint16be,
-    data: types19.array(types19.uint16be, types19.uint16be, "bytes")
+    type: types17.uint16be,
+    data: types17.array(types17.uint16be, types17.uint16be, "bytes")
   };
   type = _EllipticCurves.type;
   data = [];
@@ -8249,14 +8275,14 @@ var EllipticCurves = class _EllipticCurves {
   static fromData(buf) {
     return new _EllipticCurves({
       type: _EllipticCurves.type,
-      data: decode18(buf, _EllipticCurves.spec.data)
+      data: decode16(buf, _EllipticCurves.spec.data)
     });
   }
   static deSerialize(buf) {
-    return new _EllipticCurves(decode18(buf, _EllipticCurves.spec));
+    return new _EllipticCurves(decode16(buf, _EllipticCurves.spec));
   }
   serialize() {
-    return Buffer.from(encode19(this, _EllipticCurves.spec).slice());
+    return Buffer.from(encode17(this, _EllipticCurves.spec).slice());
   }
   get extension() {
     return {
@@ -8267,14 +8293,14 @@ var EllipticCurves = class _EllipticCurves {
 };
 
 // ../dtls/src/handshake/extensions/signature.ts
-import { decode as decode19, encode as encode20, types as types20 } from "@shinyoshiaki/binary-data";
+import { decode as decode17, encode as encode18, types as types18 } from "@shinyoshiaki/binary-data";
 var Signature = class _Signature {
   static type = 13;
   static spec = {
-    type: types20.uint16be,
-    data: types20.array(
-      { hash: types20.uint8, signature: types20.uint8 },
-      types20.uint16be,
+    type: types18.uint16be,
+    data: types18.array(
+      { hash: types18.uint8, signature: types18.uint8 },
+      types18.uint16be,
       "bytes"
     )
   };
@@ -8288,10 +8314,10 @@ var Signature = class _Signature {
     return v;
   }
   static deSerialize(buf) {
-    return new _Signature(decode19(buf, _Signature.spec));
+    return new _Signature(decode17(buf, _Signature.spec));
   }
   serialize() {
-    const res = encode20(this, _Signature.spec).slice();
+    const res = encode18(this, _Signature.spec).slice();
     return Buffer.from(res);
   }
   static fromData(buf) {
@@ -8308,23 +8334,23 @@ var Signature = class _Signature {
 };
 
 // ../dtls/src/handshake/message/alert.ts
-import { decode as decode20, encode as encode21, types as types21 } from "@shinyoshiaki/binary-data";
+import { decode as decode18, encode as encode19, types as types19 } from "@shinyoshiaki/binary-data";
 var Alert = class _Alert {
   constructor(level, description) {
     this.level = level;
     this.description = description;
   }
   static spec = {
-    level: types21.uint8,
-    description: types21.uint8
+    level: types19.uint8,
+    description: types19.uint8
   };
   static deSerialize(buf) {
     return new _Alert(
-      ...Object.values(decode20(buf, _Alert.spec))
+      ...Object.values(decode18(buf, _Alert.spec))
     );
   }
   serialize() {
-    const res = encode21(this, _Alert.spec).slice();
+    const res = encode19(this, _Alert.spec).slice();
     return Buffer.from(res);
   }
 };
@@ -8396,32 +8422,32 @@ var IPV4_PROTOCOL = 1;
 var IPV6_PROTOCOL = 2;
 
 // ../ice/src/stun/message.ts
-import { jspack as jspack4 } from "@shinyoshiaki/jspack";
 import crc32 from "buffer-crc32";
 
 // ../ice/src/stun/attributes.ts
-import { jspack as jspack3 } from "@shinyoshiaki/jspack";
 import * as Int64 from "int64-buffer";
 import nodeIp from "ip";
-import range from "lodash/range.js";
 function packAddress(value) {
   const [address] = value;
   const protocol = nodeIp.isV4Format(address) ? IPV4_PROTOCOL : IPV6_PROTOCOL;
-  return Buffer.concat([
-    Buffer.from(jspack3.Pack("!BBH", [0, protocol, value[1]])),
-    nodeIp.toBuffer(address)
-  ]);
+  const buffer2 = Buffer.alloc(4);
+  buffer2.writeUInt8(0, 0);
+  buffer2.writeUInt8(protocol, 1);
+  buffer2.writeUInt16BE(value[1], 2);
+  return Buffer.concat([buffer2, nodeIp.toBuffer(address)]);
 }
 function unpackErrorCode(data) {
   if (data.length < 4) throw new Error("STUN error code is less than 4 bytes");
-  const [, codeHigh, codeLow] = jspack3.Unpack("!HBB", data.slice(0, 4));
+  const codeHigh = data.readUInt8(2);
+  const codeLow = data.readUInt8(3);
   const reason = data.slice(4).toString("utf8");
   return [codeHigh * 100 + codeLow, reason];
 }
 function unpackAddress(data) {
   if (data.length < 4)
     throw new Error("STUN address length is less than 4 bytes");
-  const [, protocol, port] = jspack3.Unpack("!BBH", data.slice(0, 4));
+  const protocol = data.readUInt8(1);
+  const port = data.readUInt16BE(2);
   const address = data.slice(4);
   switch (protocol) {
     case IPV4_PROTOCOL:
@@ -8436,13 +8462,13 @@ function unpackAddress(data) {
       throw new Error("STUN address has unknown protocol");
   }
 }
+var cookieBuffer = Buffer.alloc(6);
+cookieBuffer.writeUInt16BE(COOKIE >> 16, 0);
+cookieBuffer.writeUInt32BE(COOKIE, 2);
 function xorAddress(data, transactionId) {
-  const xPad = [
-    ...jspack3.Pack("!HI", [COOKIE >> 16, COOKIE]),
-    ...transactionId
-  ];
+  const xPad = [...cookieBuffer, ...transactionId];
   let xData = data.slice(0, 2);
-  for (const i of range(2, data.length)) {
+  for (let i = 2; i < data.length; i++) {
     const num = data[i] ^ xPad[i - 2];
     const buf = Buffer.alloc(1);
     buf.writeUIntBE(num, 0, 1);
@@ -8454,22 +8480,28 @@ function unpackXorAddress(data, transactionId) {
   return unpackAddress(xorAddress(data, transactionId));
 }
 function packErrorCode(value) {
-  const pack = Buffer.from(
-    jspack3.Pack("!HBB", [0, Math.floor(value[0] / 100), value[0] % 100])
-  );
-  const encode22 = Buffer.from(value[1], "utf8");
-  return Buffer.concat([pack, encode22]);
+  const buffer2 = Buffer.alloc(4);
+  buffer2.writeUInt16BE(0, 0);
+  buffer2.writeUInt8(Math.floor(value[0] / 100), 2);
+  buffer2.writeUInt8(value[0] % 100, 3);
+  const encode20 = Buffer.from(value[1], "utf8");
+  return Buffer.concat([buffer2, encode20]);
 }
 function packXorAddress(value, transactionId) {
   return xorAddress(packAddress(value), transactionId);
 }
-var packUnsigned = (value) => Buffer.from(jspack3.Pack("!I", [value]));
-var unpackUnsigned = (data) => jspack3.Unpack("!I", data)[0];
-var packUnsignedShort = (value) => Buffer.concat([
-  Buffer.from(jspack3.Pack("!H", [value])),
-  Buffer.from("\0\0")
-]);
-var unpackUnsignedShort = (data) => jspack3.Unpack("!H", data.slice(0, 2))[0];
+var packUnsigned = (value) => {
+  const buffer2 = Buffer.alloc(4);
+  buffer2.writeUInt32BE(value, 0);
+  return buffer2;
+};
+var unpackUnsigned = (data) => data.readUInt32BE(0);
+var packUnsignedShort = (value) => {
+  const buffer2 = Buffer.alloc(4);
+  buffer2.writeUInt16BE(value, 0);
+  return buffer2;
+};
+var unpackUnsignedShort = (data) => data.readUInt16BE(0);
 var packUnsigned64 = (value) => {
   return new Int64.Int64BE(value.toString()).toBuffer();
 };
@@ -8531,15 +8563,12 @@ var log20 = debug("werift-ice:packages/ice/src/stun/transaction.ts");
 var log21 = debug("werift-ice : packages/ice/src/stun/protocol.ts");
 
 // ../ice/src/turn/protocol.ts
-import { jspack as jspack5 } from "@shinyoshiaki/jspack";
+import { jspack as jspack3 } from "@shinyoshiaki/jspack";
 var log22 = debug("werift-ice:packages/ice/src/turn/protocol.ts");
 
-// ../ice/src/candidate.ts
-import range2 from "lodash/range.js";
-
 // ../ice/src/ice.ts
 import * as Int642 from "int64-buffer";
-import isEqual from "lodash/isEqual.js";
+import isEqual from "fast-deep-equal";
 
 // ../ice/src/dns/lookup.ts
 import mdns from "multicast-dns";
@@ -8656,16 +8685,6 @@ var supportedAudioCodecs = supportedCodecs.filter(
   (codec) => codec.toLowerCase().startsWith("audio/")
 );
 
-// src/media/rtpReceiver.ts
-import { v4 as uuid3 } from "uuid";
-
-// src/utils.ts
-import mergeWith from "lodash/mergeWith.js";
-import now from "nano-time";
-
-// src/media/rtpTransceiver.ts
-import * as uuid from "uuid";
-
 // src/const.ts
 var DTLS_ROLE_SETUP = {
   auto: "actpass",
@@ -8679,11 +8698,15 @@ var DTLS_SETUP_ROLE = Object.keys(
   acc[key] = cur;
   return acc;
 }, {});
+var SRTP_PROFILE = {
+  SRTP_AES128_CM_HMAC_SHA1_80: ProtectionProfileAes128CmHmacSha1_80,
+  SRTP_AEAD_AES_128_GCM: ProtectionProfileAeadAes128Gcm
+};
 
 // src/media/track.ts
-import { v4 as v42 } from "uuid";
+import { randomUUID as randomUUID5 } from "crypto";
 var MediaStreamTrack = class extends EventTarget2 {
-  uuid = v42();
+  uuid = randomUUID5().toString();
   /**MediaStream ID*/
   streamId;
   remote = false;
@@ -8738,7 +8761,7 @@ var MediaStream = class {
     } else {
       Object.assign(this, props);
     }
-    this.id ??= v42();
+    this.id ??= randomUUID5().toString();
   }
   addTrack(track) {
     track.streamId = this.id;
@@ -8757,10 +8780,11 @@ var MediaStream = class {
 
 // src/utils.ts
 var log26 = debug("werift:packages/webrtc/src/utils.ts");
+var milliTime = Date.now;
+var startupTimestampInMicroseconds = BigInt(Date.now()) * 1000n - process.hrtime.bigint() / 1000n;
 var createSelfSignedCertificate = CipherContext.createSelfSignedCertificateWithKey;
 
 // src/media/receiver/nack.ts
-import range3 from "lodash/range.js";
 var log27 = debug("werift:packages/webrtc/src/media/receiver/nack.ts");
 var LOST_SIZE2 = 30 * 5;
 
@@ -8772,23 +8796,18 @@ import * as Int643 from "int64-buffer";
 
 // src/transport/dtls.ts
 import { Certificate as Certificate3, PrivateKey as PrivateKey2 } from "@fidm/x509";
-import { v4 as v43 } from "uuid";
 var log29 = debug("werift:packages/webrtc/src/transport/dtls.ts");
 
 // src/transport/ice.ts
-import { v4 as v44 } from "uuid";
 var log30 = debug("werift:packages/webrtc/src/transport/ice.ts");
 
 // src/transport/sctp.ts
-import { jspack as jspack9 } from "@shinyoshiaki/jspack";
-import * as uuid2 from "uuid";
+import { jspack as jspack6 } from "@shinyoshiaki/jspack";
 
 // ../sctp/src/sctp.ts
-import { jspack as jspack8 } from "@shinyoshiaki/jspack";
-import range5 from "lodash/range.js";
+import { jspack as jspack5 } from "@shinyoshiaki/jspack";
 
 // ../sctp/src/chunk.ts
-import { jspack as jspack6 } from "@shinyoshiaki/jspack";
 import crc32c from "turbo-crc32/crc32c.js";
 var Chunk = class _Chunk {
   constructor(flags = 0, _body = Buffer.from("")) {
@@ -8807,10 +8826,12 @@ var Chunk = class _Chunk {
   }
   get bytes() {
     if (!this.body) throw new Error();
+    const header = Buffer.alloc(4);
+    header.writeUInt8(this.type, 0);
+    header.writeUInt8(this.flags, 1);
+    header.writeUInt16BE(this.body.length + 4, 2);
     const data = Buffer.concat([
-      Buffer.from(
-        jspack6.Pack("!BBH", [this.type, this.flags, this.body.length + 4])
-      ),
+      header,
       this.body,
       ...[...Array(padL(this.body.length))].map(() => Buffer.from("\0"))
     ]);
@@ -8822,13 +8843,11 @@ var BaseInitChunk = class extends Chunk {
     super(flags, body);
     this.flags = flags;
     if (body) {
-      [
-        this.initiateTag,
-        this.advertisedRwnd,
-        this.outboundStreams,
-        this.inboundStreams,
-        this.initialTsn
-      ] = jspack6.Unpack("!LLHHL", body);
+      this.initiateTag = body.readUInt32BE(0);
+      this.advertisedRwnd = body.readUInt32BE(4);
+      this.outboundStreams = body.readUInt16BE(8);
+      this.inboundStreams = body.readUInt16BE(10);
+      this.initialTsn = body.readUInt32BE(12);
       this.params = decodeParams(body.slice(16));
     } else {
       this.initiateTag = 0;
@@ -8846,17 +8865,13 @@ var BaseInitChunk = class extends Chunk {
   initialTsn;
   params;
   get body() {
-    let body = Buffer.from(
-      jspack6.Pack("!LLHHL", [
-        this.initiateTag,
-        this.advertisedRwnd,
-        this.outboundStreams,
-        this.inboundStreams,
-        this.initialTsn
-      ])
-    );
-    body = Buffer.concat([body, encodeParams(this.params)]);
-    return body;
+    const body = Buffer.alloc(16);
+    body.writeUInt32BE(this.initiateTag, 0);
+    body.writeUInt32BE(this.advertisedRwnd, 4);
+    body.writeUInt16BE(this.outboundStreams, 8);
+    body.writeUInt16BE(this.inboundStreams, 10);
+    body.writeUInt32BE(this.initialTsn, 12);
+    return Buffer.concat([body, encodeParams(this.params)]);
   }
 };
 var InitChunk = class _InitChunk extends BaseInitChunk {
@@ -8876,12 +8891,10 @@ var ForwardTsnChunk = class _ForwardTsnChunk extends Chunk {
     super(flags, body);
     this.flags = flags;
     if (body) {
-      this.cumulativeTsn = jspack6.Unpack("!L", body)[0];
+      this.cumulativeTsn = body.readUInt32BE(0);
       let pos = 4;
       while (pos < body.length) {
-        this.streams.push(
-          jspack6.Unpack("!HH", body.slice(pos))
-        );
+        this.streams.push([body.readUInt16BE(pos), body.readUInt16BE(pos + 2)]);
         pos += 4;
       }
     } else {
@@ -8897,12 +8910,16 @@ var ForwardTsnChunk = class _ForwardTsnChunk extends Chunk {
   set body(_) {
   }
   get body() {
-    const body = Buffer.from(jspack6.Pack("!L", [this.cumulativeTsn]));
+    const body = Buffer.alloc(4);
+    body.writeUInt32BE(this.cumulativeTsn, 0);
     return Buffer.concat([
       body,
-      ...this.streams.map(
-        ([id, seq]) => Buffer.from(jspack6.Pack("!HH", [id, seq]))
-      )
+      ...this.streams.map(([id, seq]) => {
+        const streamBuffer = Buffer.alloc(4);
+        streamBuffer.writeUInt16BE(id, 0);
+        streamBuffer.writeUInt16BE(seq, 2);
+        return streamBuffer;
+      })
     ]);
   }
 };
@@ -8911,7 +8928,10 @@ var DataChunk = class _DataChunk extends Chunk {
     super(flags, body);
     this.flags = flags;
     if (body) {
-      [this.tsn, this.streamId, this.streamSeqNum, this.protocol] = jspack6.Unpack("!LHHL", body);
+      this.tsn = body.readUInt32BE(0);
+      this.streamId = body.readUInt16BE(4);
+      this.streamSeqNum = body.readUInt16BE(6);
+      this.protocol = body.readUInt32BE(8);
       this.userData = body.slice(12);
     }
   }
@@ -8935,20 +8955,15 @@ var DataChunk = class _DataChunk extends Chunk {
   sentTime;
   get bytes() {
     const length = 16 + this.userData.length;
-    let data = Buffer.concat([
-      Buffer.from(
-        jspack6.Pack("!BBHLHHL", [
-          this.type,
-          this.flags,
-          length,
-          this.tsn,
-          this.streamId,
-          this.streamSeqNum,
-          this.protocol
-        ])
-      ),
-      this.userData
-    ]);
+    const header = Buffer.alloc(16);
+    header.writeUInt8(this.type, 0);
+    header.writeUInt8(this.flags, 1);
+    header.writeUInt16BE(length, 2);
+    header.writeUInt32BE(this.tsn, 4);
+    header.writeUInt16BE(this.streamId, 8);
+    header.writeUInt16BE(this.streamSeqNum, 10);
+    header.writeUInt32BE(this.protocol, 12);
+    let data = Buffer.concat([header, this.userData]);
     if (length % 4) {
       data = Buffer.concat([
         data,
@@ -9041,18 +9056,17 @@ var SackChunk = class _SackChunk extends Chunk {
     super(flags, body);
     this.flags = flags;
     if (body) {
-      const [cumulativeTsn, advertisedRwnd, nbGaps, nbDuplicates] = jspack6.Unpack("!LLHH", body);
-      this.cumulativeTsn = cumulativeTsn;
-      this.advertisedRwnd = advertisedRwnd;
+      this.cumulativeTsn = body.readUInt32BE(0);
+      this.advertisedRwnd = body.readUInt32BE(4);
+      const nbGaps = body.readUInt16BE(8);
+      const nbDuplicates = body.readUInt16BE(10);
       let pos = 12;
       [...Array(nbGaps)].forEach(() => {
-        this.gaps.push(
-          jspack6.Unpack("!HH", body.slice(pos))
-        );
+        this.gaps.push([body.readUInt16BE(pos), body.readUInt16BE(pos + 2)]);
         pos += 4;
       });
       [...Array(nbDuplicates)].forEach(() => {
-        this.duplicates.push(jspack6.Unpack("!L", body.slice(pos))[0]);
+        this.duplicates.push(body.readUInt32BE(pos));
         pos += 4;
       });
     }
@@ -9067,24 +9081,30 @@ var SackChunk = class _SackChunk extends Chunk {
   advertisedRwnd = 0;
   get bytes() {
     const length = 16 + 4 * (this.gaps.length + this.duplicates.length);
-    let data = Buffer.from(
-      jspack6.Pack("!BBHLLHH", [
-        this.type,
-        this.flags,
-        length,
-        this.cumulativeTsn,
-        this.advertisedRwnd,
-        this.gaps.length,
-        this.duplicates.length
-      ])
-    );
-    data = Buffer.concat([
-      data,
-      ...this.gaps.map((gap) => Buffer.from(jspack6.Pack("!HH", gap)))
+    const header = Buffer.alloc(16);
+    header.writeUInt8(this.type, 0);
+    header.writeUInt8(this.flags, 1);
+    header.writeUInt16BE(length, 2);
+    header.writeUInt32BE(this.cumulativeTsn, 4);
+    header.writeUInt32BE(this.advertisedRwnd, 8);
+    header.writeUInt16BE(this.gaps.length, 12);
+    header.writeUInt16BE(this.duplicates.length, 14);
+    let data = Buffer.concat([
+      header,
+      ...this.gaps.map((gap) => {
+        const gapBuffer = Buffer.alloc(4);
+        gapBuffer.writeUInt16BE(gap[0], 0);
+        gapBuffer.writeUInt16BE(gap[1], 2);
+        return gapBuffer;
+      })
     ]);
     data = Buffer.concat([
       data,
-      ...this.duplicates.map((tsn) => Buffer.from(jspack6.Pack("!L", [tsn])))
+      ...this.duplicates.map((tsn) => {
+        const tsnBuffer = Buffer.alloc(4);
+        tsnBuffer.writeUInt32BE(tsn, 0);
+        return tsnBuffer;
+      })
     ]);
     return data;
   }
@@ -9094,7 +9114,7 @@ var ShutdownChunk = class _ShutdownChunk extends Chunk {
     super(flags, body);
     this.flags = flags;
     if (body) {
-      this.cumulativeTsn = jspack6.Unpack("!L", body)[0];
+      this.cumulativeTsn = body.readUInt32BE(0);
     }
   }
   static type = 7;
@@ -9103,7 +9123,9 @@ var ShutdownChunk = class _ShutdownChunk extends Chunk {
   }
   cumulativeTsn = 0;
   get body() {
-    return Buffer.from(jspack6.Pack("!L", [this.cumulativeTsn]));
+    const body = Buffer.alloc(4);
+    body.writeUInt32BE(this.cumulativeTsn, 0);
+    return body;
   }
 };
 var ShutdownAckChunk = class _ShutdownAckChunk extends Chunk {
@@ -9151,12 +9173,10 @@ function encodeParams(params) {
   let padding = Buffer.from("");
   params.forEach(([type, value]) => {
     const length = value.length + 4;
-    body = Buffer.concat([
-      body,
-      padding,
-      Buffer.from(jspack6.Pack("!HH", [type, length])),
-      value
-    ]);
+    const paramHeader = Buffer.alloc(4);
+    paramHeader.writeUInt16BE(type, 0);
+    paramHeader.writeUInt16BE(length, 2);
+    body = Buffer.concat([body, padding, paramHeader, value]);
     padding = Buffer.concat(
       [...Array(padL(length))].map(() => Buffer.from("\0"))
     );
@@ -9167,7 +9187,8 @@ function decodeParams(body) {
   const params = [];
   let pos = 0;
   while (pos <= body.length - 4) {
-    const [type, length] = jspack6.Unpack("!HH", body.slice(pos));
+    const type = body.readUInt16BE(pos);
+    const length = body.readUInt16BE(pos + 2);
     params.push([type, body.slice(pos + 4, pos + length)]);
     pos += length + padL(length);
   }
@@ -9175,8 +9196,7 @@ function decodeParams(body) {
 }
 
 // ../sctp/src/param.ts
-import { jspack as jspack7 } from "@shinyoshiaki/jspack";
-import range4 from "lodash/range.js";
+import { jspack as jspack4 } from "@shinyoshiaki/jspack";
 
 // ../sctp/src/sctp.ts
 var log31 = debug("werift/sctp/sctp");
@@ -9194,41 +9214,56 @@ var log33 = debug("werift:packages/webrtc/src/media/rtpReceiver.ts");
 var log34 = debug("werift:packages/webrtc/src/media/router.ts");
 
 // src/media/rtpSender.ts
-import { jspack as jspack10 } from "@shinyoshiaki/jspack";
-import * as uuid4 from "uuid";
+import { jspack as jspack7 } from "@shinyoshiaki/jspack";
 var log35 = debug("werift:packages/webrtc/src/media/rtpSender.ts");
 
+// src/sctpManager.ts
+var log36 = debug("werift:packages/webrtc/src/transport/sctpManager.ts");
+
+// src/secureTransportManager.ts
+var log37 = debug(
+  "werift:packages/webrtc/src/transport/secureTransportManager.ts"
+);
+var srtpProfiles = [
+  SRTP_PROFILE.SRTP_AEAD_AES_128_GCM,
+  // prefer
+  SRTP_PROFILE.SRTP_AES128_CM_HMAC_SHA1_80
+];
+
 // src/peerConnection.ts
-import cloneDeep from "lodash/cloneDeep.js";
-import isEqual2 from "lodash/isEqual.js";
-import * as uuid5 from "uuid";
-var log36 = debug("werift:packages/webrtc/src/peerConnection.ts");
-var defaultPeerConfig = {
-  codecs: {
-    audio: [useOPUS(), usePCMU()],
-    video: [useVP8()]
-  },
-  headerExtensions: {
-    audio: [],
-    video: []
-  },
-  iceTransportPolicy: "all",
-  iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
-  icePortRange: void 0,
-  iceInterfaceAddresses: void 0,
-  iceAdditionalHostAddresses: void 0,
-  iceUseIpv4: true,
-  iceUseIpv6: true,
-  iceFilterStunResponse: void 0,
-  iceFilterCandidatePair: void 0,
-  icePasswordPrefix: void 0,
-  iceUseLinkLocalAddress: void 0,
-  dtls: {},
-  bundlePolicy: "max-compat",
-  debug: {},
-  midSuffix: false,
-  forceTurnTCP: false
-};
+var log38 = debug("werift:packages/webrtc/src/peerConnection.ts");
+function generateDefaultPeerConfig() {
+  return {
+    codecs: {
+      audio: [useOPUS(), usePCMU()],
+      video: [useVP8()]
+    },
+    headerExtensions: {
+      audio: [],
+      video: []
+    },
+    iceTransportPolicy: "all",
+    iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
+    icePortRange: void 0,
+    iceInterfaceAddresses: void 0,
+    iceAdditionalHostAddresses: void 0,
+    iceUseIpv4: true,
+    iceUseIpv6: true,
+    iceFilterStunResponse: void 0,
+    iceFilterCandidatePair: void 0,
+    icePasswordPrefix: void 0,
+    iceUseLinkLocalAddress: void 0,
+    dtls: {},
+    bundlePolicy: "max-compat",
+    debug: {},
+    midSuffix: false,
+    forceTurnTCP: false
+  };
+}
+var defaultPeerConfig = generateDefaultPeerConfig();
+
+// src/transceiverManager.ts
+var log39 = debug("werift:packages/webrtc/src/media/rtpTransceiverManager.ts");
 
 // src/nonstandard/navigator.ts
 var Navigator = class {
@@ -9251,7 +9286,7 @@ var MediaDevices = class extends EventTarget {
     if (video) {
       this.video?.onReceiveRtp.subscribe((rtp) => {
         const cloned = rtp.clone();
-        cloned.header.ssrc = jspack11.Unpack("!L", randomBytes4(4))[0];
+        cloned.header.ssrc = jspack8.Unpack("!L", randomBytes5(4))[0];
         video.onReceiveRtp.execute(cloned);
       });
     }
@@ -9259,7 +9294,7 @@ var MediaDevices = class extends EventTarget {
     if (audio) {
       this.audio?.onReceiveRtp.subscribe((rtp) => {
         const cloned = rtp.clone();
-        cloned.header.ssrc = jspack11.Unpack("!L", randomBytes4(4))[0];
+        cloned.header.ssrc = jspack8.Unpack("!L", randomBytes5(4))[0];
         audio.onReceiveRtp.execute(cloned);
       });
     }
@@ -9490,9 +9525,9 @@ var MediaRecorder = class {
 
 // src/nonstandard/userMedia.ts
 import { exec } from "child_process";
+import { randomUUID as randomUUID6 } from "crypto";
 import { createSocket as createSocket4 } from "dgram";
 import { setImmediate as setImmediate2 } from "timers/promises";
-import { v4 as v48 } from "uuid";
 var getUserMedia = async ({
   path: path2,
   loop,
@@ -9527,7 +9562,7 @@ var MediaPlayer = class {
     this.setupTrack(props.audioPort, this.audio);
     this.setupTrack(props.videoPort, this.video);
   }
-  streamId = v48();
+  streamId = randomUUID6().toString();
   audio = new MediaStreamTrack({ kind: "audio", streamId: this.streamId });
   video = new MediaStreamTrack({ kind: "video", streamId: this.streamId });
   process;
@@ -9712,10 +9747,12 @@ export {
   createBufferWriter,
   dePacketizeRtpPackets,
   debug,
+  decodeVintEncodedNumber,
   depacketizeTransformer,
   depacketizerCodecs,
   deserializeAbsSendTime,
   deserializeAudioLevelIndication,
+  deserializeSimpleBlocks,
   deserializeString,
   deserializeUint16BE,
   deserializeVideoOrientation,
@@ -9761,6 +9798,7 @@ export {
   serializeRepairedRtpStreamId,
   serializeSdesMid,
   serializeSdesRTPStreamID,
+  serializeSimpleBlock,
   serializeTransportWideCC,
   string,
   stringToByteArray,
@@ -9775,6 +9813,7 @@ export {
   uint8Add,
   unknownSizeElement,
   unwrapRtx,
+  vintDecode,
   vintEncode,
   vintEncodedNumber,
   wrapRtx