werift 0.24.0 → 0.24.1

package/lib/index.mjs

@@ -1,11 +1,10 @@
 // ../common/src/binary.ts
 import { randomBytes } from "crypto";
-import { jspack } from "@shinyoshiaki/jspack";
 function random16() {
-  return jspack.Unpack("!H", randomBytes(2))[0];
+  return randomBytes(2).readUInt16BE(0);
 }
 function random32() {
-  return jspack.Unpack("!L", randomBytes(4))[0];
+  return randomBytes(4).readUInt32BE(0);
 }
 function bufferXor(a, b) {
   if (a.length !== b.length) {
@@ -2600,8 +2599,25 @@ var saltLength = (profile) => {
   }
 };
 
+// ../rtp/src/codec/leb128.ts
+function leb128encode(value) {
+  if (!Number.isInteger(value) || value < 0 || !Number.isSafeInteger(value)) {
+    throw new Error("LEB128 encode requires a non-negative safe integer");
+  }
+  const bytes = [];
+  let remaining = value;
+  do {
+    let byte = remaining & 127;
+    remaining = Math.floor(remaining / 128);
+    if (remaining !== 0) {
+      byte |= 128;
+    }
+    bytes.push(byte);
+  } while (remaining !== 0);
+  return Buffer.from(bytes);
+}
+
 // ../rtp/src/codec/av1.ts
-import { LEB128 } from "@minhducsun2002/leb128";
 var log3 = debug("werift-rtp : packages/rtp/src/codec/av1.ts");
 var AV1RtpPayload = class _AV1RtpPayload {
   /**
@@ -2731,7 +2747,7 @@ var AV1Obu = class _AV1Obu {
     const header = new BitWriter2(8).set(this.obu_forbidden_bit).set(OBU_TYPE_IDS[this.obu_type], 4).set(this.obu_extension_flag).set(this.obu_has_size_field).set(this.obu_reserved_1bit).buffer;
     let obuSize = Buffer.alloc(0);
     if (this.obu_has_size_field) {
-      obuSize = LEB128.encode(this.payload.length);
+      obuSize = leb128encode(this.payload.length);
     }
     return Buffer.concat([header, obuSize, this.payload]);
   }
@@ -2740,14 +2756,20 @@ function leb128decode(buf) {
   let value = 0;
   let leb128bytes = 0;
   for (let i = 0; i < 8; i++) {
+    if (i >= buf.length) {
+      throw new Error("LEB128 decode incomplete");
+    }
     const leb128byte = buf.readUInt8(i);
-    value |= (leb128byte & 127) << i * 7;
+    value += (leb128byte & 127) * 128 ** i;
     leb128bytes++;
     if (!(leb128byte & 128)) {
-      break;
+      if (!Number.isSafeInteger(value)) {
+        throw new Error("LEB128 value exceeds safe integer");
+      }
+      return [value, leb128bytes];
     }
   }
-  return [value, leb128bytes];
+  throw new Error("LEB128 decode incomplete");
 }
 var OBU_TYPES = {
   0: "Reserved",
@@ -4694,13 +4716,12 @@ var RtpPacket = class _RtpPacket {
 };
 
 // ../rtp/src/rtp/rtx.ts
-import { jspack as jspack2 } from "@shinyoshiaki/jspack";
 function unwrapRtx(rtx, payloadType, ssrc) {
   const packet = new RtpPacket(
     new RtpHeader({
       payloadType,
       marker: rtx.header.marker,
-      sequenceNumber: jspack2.Unpack("!H", rtx.payload.subarray(0, 2))[0],
+      sequenceNumber: rtx.payload.readUInt16BE(0),
       timestamp: rtx.header.timestamp,
       ssrc
     }),
@@ -4709,6 +4730,8 @@ function unwrapRtx(rtx, payloadType, ssrc) {
   return packet;
 }
 function wrapRtx(packet, payloadType, sequenceNumber, ssrc) {
+  const originalSequence = Buffer.allocUnsafe(2);
+  originalSequence.writeUInt16BE(packet.header.sequenceNumber, 0);
   const rtx = new RtpPacket(
     new RtpHeader({
       payloadType,
@@ -4719,17 +4742,13 @@ function wrapRtx(packet, payloadType, sequenceNumber, ssrc) {
       csrc: packet.header.csrc,
       extensions: packet.header.extensions
     }),
-    Buffer.concat([
-      Buffer.from(jspack2.Pack("!H", [packet.header.sequenceNumber])),
-      packet.payload
-    ])
+    Buffer.concat([originalSequence, packet.payload])
   );
   return rtx;
 }
 
 // ../rtp/src/srtp/context/context.ts
-import { createHmac as createHmac3 } from "crypto";
-import AES from "aes-js";
+import { createCipheriv as createCipheriv4, createHmac as createHmac3 } from "crypto";
 
 // ../rtp/src/srtp/cipher/ctr.ts
 import {
@@ -5117,6 +5136,11 @@ function finalizeAuthenticatedDecryption(decipher, packetType) {
 }
 
 // ../rtp/src/srtp/context/context.ts
+function aes128EcbEncrypt(key, plaintext) {
+  const cipher = createCipheriv4("aes-128-ecb", key, null);
+  cipher.setAutoPadding(false);
+  return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
 var Context = class {
   constructor(masterKey, masterSalt, profile) {
     this.masterKey = masterKey;
@@ -5183,8 +5207,7 @@ var Context = class {
       sessionKey[j] = sessionKey[j] ^ labelAndIndexOverKdr[i];
     }
     sessionKey = Buffer.concat([sessionKey, Buffer.from([0, 0])]);
-    const block = new AES.AES(this.masterKey);
-    return Buffer.from(block.encrypt(sessionKey));
+    return aes128EcbEncrypt(this.masterKey, sessionKey);
   }
   generateSessionSalt(label) {
     let sessionSalt = Buffer.from(this.masterSalt);
@@ -5201,8 +5224,7 @@ var Context = class {
       sessionSalt[j] = sessionSalt[j] ^ labelAndIndexOverKdr[i];
     }
     sessionSalt = Buffer.concat([sessionSalt, Buffer.from([0, 0])]);
-    const block = new AES.AES(this.masterKey);
-    sessionSalt = Buffer.from(block.encrypt(sessionSalt));
+    sessionSalt = aes128EcbEncrypt(this.masterKey, sessionSalt);
     return sessionSalt.subarray(0, 14);
   }
   generateSessionAuthTag(label) {
@@ -5227,9 +5249,8 @@ var Context = class {
       sessionAuthTag,
       Buffer.from([0, 1])
     ]);
-    const block = new AES.AES(this.masterKey);
-    firstRun = Buffer.from(block.encrypt(firstRun));
-    secondRun = Buffer.from(block.encrypt(secondRun));
+    firstRun = aes128EcbEncrypt(this.masterKey, firstRun);
+    secondRun = aes128EcbEncrypt(this.masterKey, secondRun);
     return Buffer.concat([firstRun, secondRun.subarray(0, 4)]);
   }
   getSrtpSsrcState(ssrc) {
@@ -6735,17 +6756,82 @@ import { connect as connect3, createServer } from "node:net";
 // ../ice-server/src/stun/message.ts
 import { createHmac as createHmac4, randomBytes as randomBytes5 } from "crypto";
 
+// ../ice-server/src/stun/ip.ts
+import { isIPv4, isIPv6 } from "node:net";
+function ipAddressToBuffer(address) {
+  if (isIPv4(address)) {
+    const buf = Buffer.allocUnsafe(4);
+    const parts = address.split(".");
+    for (let i = 0; i < 4; i++) {
+      buf[i] = Number(parts[i]) & 255;
+    }
+    return buf;
+  }
+  if (!isIPv6(address)) {
+    throw new Error(`Invalid ip address: ${address}`);
+  }
+  const sections = address.split(":", 8);
+  for (let i = 0; i < sections.length; i++) {
+    let v4Buffer;
+    if (isIPv4(sections[i])) {
+      v4Buffer = ipAddressToBuffer(sections[i]);
+      sections[i] = v4Buffer.subarray(0, 2).toString("hex");
+    }
+    if (v4Buffer && ++i < 8) {
+      sections.splice(i, 0, v4Buffer.subarray(2, 4).toString("hex"));
+    }
+  }
+  if (sections[0] === "") {
+    while (sections.length < 8) sections.unshift("0");
+  } else if (sections[sections.length - 1] === "") {
+    while (sections.length < 8) sections.push("0");
+  } else if (sections.length < 8) {
+    let emptyIndex = 0;
+    for (; emptyIndex < sections.length && sections[emptyIndex] !== ""; emptyIndex++) ;
+    const zeros = [];
+    for (let n = 9 - sections.length; n > 0; n--) {
+      zeros.push("0");
+    }
+    sections.splice(emptyIndex, 1, ...zeros);
+  }
+  const result = Buffer.allocUnsafe(16);
+  let offset = 0;
+  for (const section of sections) {
+    const word = Number.parseInt(section, 16) || 0;
+    result[offset++] = word >> 8 & 255;
+    result[offset++] = word & 255;
+  }
+  return result;
+}
+function bufferToIpAddress(buf) {
+  if (buf.length === 4) {
+    return `${buf[0]}.${buf[1]}.${buf[2]}.${buf[3]}`;
+  }
+  if (buf.length !== 16) {
+    throw new Error(`Invalid ip address buffer length: ${buf.length}`);
+  }
+  const hextets = [];
+  for (let i = 0; i < 16; i += 2) {
+    hextets.push(buf.readUInt16BE(i).toString(16));
+  }
+  let result = hextets.join(":");
+  result = result.replace(/(^|:)0(:0)*:0(:|$)/, "$1::$3");
+  result = result.replace(/:{3,4}/, "::");
+  return result;
+}
+function isIpV4Address(address) {
+  return isIPv4(address);
+}
+
 // ../ice-server/src/stun/attributes.ts
-import * as Int64 from "int64-buffer";
-import nodeIp from "ip";
 function packAddress(value) {
   const [address] = value;
-  const protocol = nodeIp.isV4Format(address) ? IPV4_PROTOCOL : IPV6_PROTOCOL;
+  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, nodeIp.toBuffer(address)]);
+  return Buffer.concat([buffer2, ipAddressToBuffer(address)]);
 }
 function unpackErrorCode(data) {
   if (data.length < 4) {
@@ -6768,12 +6854,12 @@ function unpackAddress(data) {
       if (address.length !== 4) {
         throw new Error("STUN address has invalid length for IPv4");
       }
-      return [nodeIp.toString(address), port];
+      return [bufferToIpAddress(address), port];
     case IPV6_PROTOCOL:
       if (address.length !== 16) {
         throw new Error("STUN address has invalid length for IPv6");
       }
-      return [nodeIp.toString(address), port];
+      return [bufferToIpAddress(address), port];
     default:
       throw new Error("STUN address has unknown protocol");
   }
@@ -6836,12 +6922,11 @@ var packUnsignedShort = (value) => {
 };
 var unpackUnsignedShort = (data) => data.readUInt16BE(0);
 var packUnsigned64 = (value) => {
-  return new Int64.Int64BE(value.toString()).toBuffer();
-};
-var unpackUnsigned64 = (data) => {
-  const int2 = new Int64.Int64BE(data);
-  return BigInt(int2.toString());
+  const buffer2 = Buffer.allocUnsafe(8);
+  buffer2.writeBigUInt64BE(value, 0);
+  return buffer2;
 };
+var unpackUnsigned64 = (data) => data.readBigUInt64BE(0);
 var packString = (value) => Buffer.from(value, "utf8");
 var unpackString = (data) => data.toString("utf8");
 var packSoftware = (value) => {
@@ -8086,7 +8171,7 @@ function makeIntegrityKey(username, realm, password) {
 
 // ../ice/src/candidate.ts
 import { createHash as createHash3, randomUUID } from "crypto";
-import { isIPv4 } from "net";
+import { isIPv4 as isIPv42 } from "net";
 var Candidate = class _Candidate {
   constructor(foundation, component, transport, priority, host, port, type, relatedAddress, relatedPort, tcptype, generation, ufrag) {
     this.foundation = foundation;
@@ -8151,8 +8236,8 @@ var Candidate = class _Candidate {
     );
   }
   canPairWith(other) {
-    const a = isIPv4(this.host);
-    const b = isIPv4(other.host);
+    const a = isIPv42(this.host);
+    const b = isIPv42(other.host);
     return this.component === other.component && this.transport.toLowerCase() === other.transport.toLowerCase() && canPairTcpCandidates(this, other) && a === b;
   }
   toSdp() {
@@ -8257,10 +8342,8 @@ function remoteTcpTypeForIncoming(localTcpType) {
 
 // ../ice/src/ice.ts
 import { randomBytes as randomBytes7 } from "crypto";
-import { isIPv4 as isIPv42 } from "net";
-import * as Int642 from "int64-buffer";
+import { isIPv4 as isIPv43 } from "net";
 import * as timers from "node:timers/promises";
-import isEqual from "fast-deep-equal";
 
 // ../ice/src/dns/lookup.ts
 import mdns from "multicast-dns";
@@ -8461,7 +8544,34 @@ function validateAddress(addr) {
 
 // ../ice/src/utils.ts
 import * as os from "node:os";
-import nodeIp2 from "ip";
+
+// ../ice/src/internal/selectAddresses.ts
+function selectAddressesFromInterfaces(interfaces, family, options = {}, isLinkLocal) {
+  const costlyNetworks = ["ipsec", "tun", "utun", "tap"];
+  const banNetworks = ["vmnet", "veth"];
+  const { useLinkLocalAddress } = options;
+  const all = Object.keys(interfaces).map((nic) => {
+    for (const word of [...costlyNetworks, ...banNetworks]) {
+      if (nic.startsWith(word)) {
+        return {
+          nic,
+          addresses: []
+        };
+      }
+    }
+    const addresses = (interfaces[nic] ?? []).filter(
+      (details) => normalizeFamilyNodeV18(details.family) === family && !details.internal && (useLinkLocalAddress ? true : !isLinkLocal(details))
+    );
+    return {
+      nic,
+      addresses: addresses.map((address) => address.address)
+    };
+  }).filter((address) => !!address);
+  all.sort((a, b) => a.nic.localeCompare(b.nic));
+  return Object.values(all).flatMap((entry) => entry.addresses);
+}
+
+// ../ice/src/utils.ts
 var logger = debug("werift-ice : packages/ice/src/utils.ts");
 async function getGlobalIp(stunServer, interfaceAddresses) {
   const protocol = new StunProtocol();
@@ -8481,29 +8591,14 @@ function isLinkLocalAddress(info) {
 function nodeIpAddress(family, {
   useLinkLocalAddress
 } = {}) {
-  const costlyNetworks = ["ipsec", "tun", "utun", "tap"];
-  const banNetworks = ["vmnet", "veth"];
   const interfaces = os.networkInterfaces();
   logger(interfaces);
-  const all = Object.keys(interfaces).map((nic) => {
-    for (const word of [...costlyNetworks, ...banNetworks]) {
-      if (nic.startsWith(word)) {
-        return {
-          nic,
-          addresses: []
-        };
-      }
-    }
-    const addresses = interfaces[nic].filter(
-      (details) => normalizeFamilyNodeV18(details.family) === family && !nodeIp2.isLoopback(details.address) && (useLinkLocalAddress ? true : !isLinkLocalAddress(details))
-    );
-    return {
-      nic,
-      addresses: addresses.map((address) => address.address)
-    };
-  }).filter((address) => !!address);
-  all.sort((a, b) => a.nic.localeCompare(b.nic));
-  return Object.values(all).flatMap((entry) => entry.addresses);
+  return selectAddressesFromInterfaces(
+    interfaces,
+    family,
+    { useLinkLocalAddress },
+    isLinkLocalAddress
+  );
 }
 function getHostAddresses(useIpv4, useIpv6, options = {}) {
   const address = [];
@@ -8556,9 +8651,7 @@ var Connection = class {
   localCandidatesEnd = false;
   generation = -1;
   userHistory = {};
-  tieBreaker = BigInt(
-    new Int642.Uint64BE(randomBytes7(64)).toString()
-  );
+  tieBreaker = randomBytes7(8).readBigUInt64BE(0);
   state = "new";
   lookup;
   _remoteCandidates = [];
@@ -8752,7 +8845,7 @@ var Connection = class {
       this.ensureProtocol(protocol);
       try {
         await protocol.connectionMade(
-          isIPv42(address),
+          isIPv43(address),
           this.options.portRange,
           this.options.interfaceAddresses
         );
@@ -8853,7 +8946,7 @@ var Connection = class {
           const stunCandidatePromise = new Promise(
             async (r, f) => {
               const timer2 = setTimeout(f, timeout * 1e3);
-              if (protocol.localCandidate?.host && isIPv42(protocol.localCandidate?.host)) {
+              if (protocol.localCandidate?.host && isIPv43(protocol.localCandidate?.host)) {
                 const candidate = await serverReflexiveCandidate(
                   protocol,
                   stunServer
@@ -9208,7 +9301,7 @@ var Connection = class {
   }
   findPair(protocol, remoteCandidate) {
     const pair = this.checkList.find(
-      (pair2) => isEqual(pair2.protocol, protocol) && isEqual(pair2.remoteCandidate, remoteCandidate)
+      (pair2) => pair2.protocol === protocol && pair2.remoteCandidate === remoteCandidate
     );
     return pair;
   }
@@ -9351,7 +9444,7 @@ var Connection = class {
         return;
       }
     }
-    if (!isEqual(result.addr, pair.remoteAddr)) {
+    if (result.addr[0] !== pair.remoteAddr[0] || result.addr[1] !== pair.remoteAddr[1]) {
       pair.updateState(4 /* FAILED */);
       this.checkComplete(pair);
       r();
@@ -10763,8 +10856,7 @@ var StreamStatistics = class {
 
 // src/sdp.ts
 import { randomBytes as randomBytes9 } from "crypto";
-import { isIPv4 as isIPv43 } from "net";
-import * as Int643 from "int64-buffer";
+import { isIPv4 as isIPv44 } from "net";
 
 // src/transport/dtls.ts
 import { Certificate as Certificate3, PrivateKey as PrivateKey2 } from "@fidm/x509";
@@ -11698,11 +11790,9 @@ var RTCIceParameters = class {
 
 // src/transport/sctp.ts
 import { randomUUID as randomUUID8 } from "crypto";
-import { jspack as jspack5 } from "@shinyoshiaki/jspack";
 
 // ../sctp/src/sctp.ts
 import { createHmac as createHmac5, randomBytes as randomBytes8 } from "crypto";
-import { jspack as jspack4 } from "@shinyoshiaki/jspack";
 
 // ../sctp/src/chunk.ts
 var Chunk = class _Chunk {
@@ -12155,7 +12245,6 @@ function createEventsFromList(list) {
 }
 
 // ../sctp/src/param.ts
-import { jspack as jspack3 } from "@shinyoshiaki/jspack";
 var OutgoingSSNResetRequestParam = class _OutgoingSSNResetRequestParam {
   // Outgoing SSN Reset Request Parameter
   constructor(requestSequence, responseSequence, lastTsn, streams) {
@@ -12169,26 +12258,26 @@ var OutgoingSSNResetRequestParam = class _OutgoingSSNResetRequestParam {
     return _OutgoingSSNResetRequestParam.type;
   }
   get bytes() {
-    const data = Buffer.from(
-      jspack3.Pack("!LLL", [
-        this.requestSequence,
-        this.responseSequence,
-        this.lastTsn
-      ])
-    );
+    const data = Buffer.allocUnsafe(12);
+    data.writeUInt32BE(this.requestSequence, 0);
+    data.writeUInt32BE(this.responseSequence, 4);
+    data.writeUInt32BE(this.lastTsn, 8);
     return Buffer.concat([
       data,
-      ...this.streams.map((stream) => Buffer.from(jspack3.Pack("!H", [stream])))
+      ...this.streams.map((stream) => {
+        const buf = Buffer.allocUnsafe(2);
+        buf.writeUInt16BE(stream, 0);
+        return buf;
+      })
     ]);
   }
   static parse(data) {
-    const [requestSequence, responseSequence, lastTsn] = jspack3.Unpack(
-      "!LLL",
-      data
-    );
+    const requestSequence = data.readUInt32BE(0);
+    const responseSequence = data.readUInt32BE(4);
+    const lastTsn = data.readUInt32BE(8);
     const stream = [];
     for (let pos = 12; pos < data.length; pos += 2) {
-      stream.push(jspack3.Unpack("!H", data.slice(pos))[0]);
+      stream.push(data.readUInt16BE(pos));
     }
     return new _OutgoingSSNResetRequestParam(
       requestSequence,
@@ -12209,12 +12298,15 @@ var StreamAddOutgoingParam = class _StreamAddOutgoingParam {
     return _StreamAddOutgoingParam.type;
   }
   get bytes() {
-    return Buffer.from(
-      jspack3.Pack("!LHH", [this.requestSequence, this.newStreams, 0])
-    );
+    const buf = Buffer.allocUnsafe(8);
+    buf.writeUInt32BE(this.requestSequence, 0);
+    buf.writeUInt16BE(this.newStreams, 4);
+    buf.writeUInt16BE(0, 6);
+    return buf;
   }
   static parse(data) {
-    const [requestSequence, newStreams] = jspack3.Unpack("!LHH", data);
+    const requestSequence = data.readUInt32BE(0);
+    const newStreams = data.readUInt16BE(4);
     return new _StreamAddOutgoingParam(requestSequence, newStreams);
   }
 };
@@ -12233,12 +12325,14 @@ var ReconfigResponseParam = class _ReconfigResponseParam {
     return _ReconfigResponseParam.type;
   }
   get bytes() {
-    return Buffer.from(
-      jspack3.Pack("!LL", [this.responseSequence, this.result])
-    );
+    const buf = Buffer.allocUnsafe(8);
+    buf.writeUInt32BE(this.responseSequence, 0);
+    buf.writeUInt32BE(this.result, 4);
+    return buf;
   }
   static parse(data) {
-    const [requestSequence, result] = jspack3.Unpack("!LL", data);
+    const requestSequence = data.readUInt32BE(0);
+    const result = data.readUInt32BE(4);
     return new _ReconfigResponseParam(requestSequence, result);
   }
 };
@@ -12507,8 +12601,10 @@ var SCTP = class _SCTP {
           ack.inboundStreams = this._inboundStreamsCount;
           ack.initialTsn = this.localTsn;
           this.setExtensions(ack.params);
-          const time = Date.now() / 1e3;
-          let cookie = Buffer.from(jspack4.Pack("!L", [time]));
+          const time = Math.floor(Date.now() / 1e3);
+          const cookieTime = Buffer.allocUnsafe(4);
+          cookieTime.writeUInt32BE(time, 0);
+          let cookie = cookieTime;
           cookie = Buffer.concat([
             cookie,
             createHmac5("sha1", this.hmacKey).update(cookie).digest()
@@ -12599,8 +12695,8 @@ var SCTP = class _SCTP {
             log30("x State cookie is invalid");
             return;
           }
-          const now = Date.now() / 1e3;
-          const stamp = jspack4.Unpack("!L", cookie)[0];
+          const now = Math.floor(Date.now() / 1e3);
+          const stamp = cookie.readUInt32BE(0);
           if (stamp < now - COOKIE_LIFETIME || stamp > now) {
             const error = new ErrorChunk(0, void 0);
             error.params.push([
@@ -13230,10 +13326,9 @@ var SCTP = class _SCTP {
     if (this.associationState !== 4 /* ESTABLISHED */) return;
     if (this.flightSize === 0 && this.outboundQueue.length === 0) {
       const heartbeat = new HeartbeatChunk();
-      heartbeat.params.push([
-        1,
-        Buffer.from(jspack4.Pack("!L", [Math.floor(Date.now() / 1e3)]))
-      ]);
+      const heartbeatTime = Buffer.allocUnsafe(4);
+      heartbeatTime.writeUInt32BE(Math.floor(Date.now() / 1e3), 0);
+      heartbeat.params.push([1, heartbeatTime]);
       await this.sendChunk(heartbeat).catch((err5) => {
         log30("send heartbeat failed", err5.message);
       });
@@ -13599,14 +13694,10 @@ var RTCSctpTransport = class _RTCSctpTransport {
               return;
             }
             if (!Object.keys(this.dataChannels).includes(streamId.toString())) {
-              const [
-                ,
-                channelType,
-                ,
-                reliability,
-                labelLength,
-                protocolLength
-              ] = jspack5.Unpack("!BBHLHH", data);
+              const channelType = data.readUInt8(1);
+              const reliability = data.readUInt32BE(4);
+              const labelLength = data.readUInt16BE(8);
+              const protocolLength = data.readUInt16BE(10);
               let pos = 12;
               const label = data.slice(pos, pos + labelLength).toString("utf8");
               pos += labelLength;
@@ -13637,11 +13728,9 @@ var RTCSctpTransport = class _RTCSctpTransport {
               log31("datachannel already opened", "retransmit ack");
             }
             const channel = this.dataChannels[streamId];
-            this.dataChannelQueue.push([
-              channel,
-              WEBRTC_DCEP,
-              Buffer.from(jspack5.Pack("!B", [DATA_CHANNEL_ACK]))
-            ]);
+            const ack = Buffer.allocUnsafe(1);
+            ack.writeUInt8(DATA_CHANNEL_ACK, 0);
+            this.dataChannelQueue.push([channel, WEBRTC_DCEP, ack]);
             await this.dataChannelFlush();
           }
           break;
@@ -13716,16 +13805,15 @@ var RTCSctpTransport = class _RTCSctpTransport {
       channelType = 2;
       reliability = channel.maxPacketLifeTime;
     }
-    const data = jspack5.Pack("!BBHLHH", [
-      DATA_CHANNEL_OPEN,
-      channelType,
-      priority,
-      reliability,
-      channel.label.length,
-      channel.protocol.length
-    ]);
+    const data = Buffer.allocUnsafe(12);
+    data.writeUInt8(DATA_CHANNEL_OPEN, 0);
+    data.writeUInt8(channelType, 1);
+    data.writeUInt16BE(priority, 2);
+    data.writeUInt32BE(reliability, 4);
+    data.writeUInt16BE(channel.label.length, 8);
+    data.writeUInt16BE(channel.protocol.length, 10);
     const send = Buffer.concat([
-      Buffer.from(data),
+      data,
       Buffer.from(channel.label, "utf8"),
       Buffer.from(channel.protocol, "utf8")
     ]);
@@ -14332,7 +14420,7 @@ function ipAddressFromSdp(sdp) {
   return m[2];
 }
 function ipAddressToSdp(addr) {
-  const version = isIPv43(addr) ? 4 : 6;
+  const version = isIPv44(addr) ? 4 : 6;
   return `IN IP${version} ${addr}`;
 }
 function candidateToSdp(c) {
@@ -14422,7 +14510,7 @@ var RTCSessionDescription = class {
 };
 function addSDPHeader(type, description) {
   const username = "-";
-  const sessionId = new Int643.Uint64BE(randomBytes9(64)).toString().slice(0, 8);
+  const sessionId = randomBytes9(8).readBigUInt64BE(0).toString().slice(0, 8);
   const sessionVersion = 0;
   description.origin = `${username} ${sessionId} ${sessionVersion} IN IP4 0.0.0.0`;
   description.msidSemantic.push(new GroupDescription("WMS", ["*"]));
@@ -14977,7 +15065,6 @@ var RtpRouter = class {
 
 // src/media/rtpSender.ts
 import { randomBytes as randomBytes10 } from "crypto";
-import { jspack as jspack6 } from "@shinyoshiaki/jspack";
 import { randomUUID as randomUUID10 } from "crypto";
 import { setTimeout as setTimeout9 } from "timers/promises";
 
@@ -15140,8 +15227,8 @@ var RTCRtpSender = class {
   }
   type = "sender";
   kind;
-  ssrc = jspack6.Unpack("!L", randomBytes10(4))[0];
-  rtxSsrc = jspack6.Unpack("!L", randomBytes10(4))[0];
+  ssrc = randomBytes10(4).readUInt32BE(0);
+  rtxSsrc = randomBytes10(4).readUInt32BE(0);
   trackId = randomUUID10().toString();
   onReady = new Event2();
   onRtcp = new Event2();