@ikonai/sdk 0.0.28 → 0.0.29

package/assets/audio-capture-worker-fxRKlQJF.js

@@ -0,0 +1,932 @@
+function U(e, t, r, i, n) {
+  const s = n?.trackId ?? 0, o = n?.sequenceId ?? 0, d = n?.flags ?? 0, c = n?.targetIds ?? [], g = n?.payloadType ?? 8, V = 27 + c.length * 4, O = V + t.length, D = new Uint8Array(O), u = new DataView(D.buffer);
+  u.setUint32(0, O, !0), u.setUint32(4, e >>> 0, !0), u.setUint32(8, i >>> 0, !0), u.setUint32(12, s >>> 0, !0), u.setUint32(16, o >>> 0, !0), u.setUint32(20, c.length >>> 0, !0), u.setUint8(24, r & 255), u.setUint8(25, g & 255), u.setUint8(26, d & 255);
+  let L = 27;
+  for (let B = 0; B < c.length; B++)
+    u.setUint32(L, c[B] >>> 0, !0), L += 4;
+  return D.set(t, V), D;
+}
+var w = /* @__PURE__ */ ((e) => (e[e.Null = 1] = "Null", e[e.Bool = 2] = "Bool", e[e.Int32 = 3] = "Int32", e[e.Int64 = 4] = "Int64", e[e.UInt32 = 5] = "UInt32", e[e.UInt64 = 6] = "UInt64", e[e.Float32 = 7] = "Float32", e[e.Float64 = 8] = "Float64", e[e.Array = 9] = "Array", e[e.Dict = 10] = "Dict", e[e.Object = 11] = "Object", e[e.String = 12] = "String", e[e.Binary = 13] = "Binary", e[e.Guid = 14] = "Guid", e))(w || {});
+const C = 161, K = 162, E = new TextEncoder();
+new TextDecoder("utf-8", { fatal: !0 });
+class y {
+  constructor(t = 1) {
+    this.version = t, this.buffer.writeByte(C), this.buffer.writeVarUInt(t >>> 0);
+  }
+  buffer = new p();
+  closed = !1;
+  cached;
+  writeInt32Field(t, r) {
+    this.writeFixedField(t, 3, () => this.buffer.writeInt32(r | 0));
+  }
+  writeUInt32Field(t, r) {
+    this.writeFixedField(t, 5, () => this.buffer.writeUInt32(r >>> 0));
+  }
+  writeInt64Field(t, r) {
+    this.writeFixedField(t, 4, () => this.buffer.writeBigInt64(r));
+  }
+  writeUInt64Field(t, r) {
+    this.writeFixedField(t, 6, () => this.buffer.writeBigUInt64(r));
+  }
+  writeFloat32Field(t, r) {
+    this.writeFixedField(t, 7, () => this.buffer.writeFloat32(r));
+  }
+  writeFloat64Field(t, r) {
+    this.writeFixedField(t, 8, () => this.buffer.writeFloat64(r));
+  }
+  writeBoolField(t, r) {
+    this.writeFixedField(t, 2, () => this.buffer.writeByte(r ? 1 : 0));
+  }
+  writeGuidField(t, r) {
+    const i = r instanceof a ? r.asBytes() : r;
+    if (i.length !== 16)
+      throw new Error("Guid payload must be 16 bytes");
+    this.writeFixedField(t, 14, () => this.buffer.writeBytes(i));
+  }
+  writeStringField(t, r) {
+    const i = E.encode(r ?? "");
+    this.writeVariableField(t, 12, i);
+  }
+  writeBinaryField(t, r) {
+    this.writeVariableField(t, 13, r);
+  }
+  writeObjectField(t, r, i) {
+    const n = new y(r);
+    i(n);
+    const s = n.finish();
+    this.writeVariableField(t, 11, s);
+  }
+  writeArrayField(t, r, i) {
+    const n = new b(r);
+    i(n);
+    const s = n.finish();
+    this.writeVariableField(t, 9, s);
+  }
+  writeDictionaryField(t, r, i, n) {
+    const s = new _(r, i);
+    n(s);
+    const o = s.finish();
+    this.writeVariableField(t, 10, o);
+  }
+  finish() {
+    return this.closed || (this.buffer.writeByte(K), this.closed = !0, this.cached = this.buffer.toUint8Array()), this.cached;
+  }
+  writeFixedField(t, r, i) {
+    this.writeFieldHeader(t, r, 0), i();
+  }
+  writeVariableField(t, r, i) {
+    this.writeFieldHeader(t, r, i.length), this.buffer.writeBytes(i);
+  }
+  writeFieldHeader(t, r, i) {
+    this.buffer.writeUInt32(t >>> 0), this.buffer.writeByte(F(r)), z(r) && this.buffer.writeVarUInt(i >>> 0);
+  }
+}
+class b {
+  constructor(t) {
+    this.elementType = t;
+  }
+  payload = new p();
+  count = 0;
+  writeInt32(t) {
+    this.ensureElementType(
+      3
+      /* Int32 */
+    ), this.count++, this.payload.writeInt32(t | 0);
+  }
+  writeUInt32(t) {
+    this.ensureElementType(
+      5
+      /* UInt32 */
+    ), this.count++, this.payload.writeUInt32(t >>> 0);
+  }
+  writeInt64(t) {
+    this.ensureElementType(
+      4
+      /* Int64 */
+    ), this.count++, this.payload.writeBigInt64(t);
+  }
+  writeUInt64(t) {
+    this.ensureElementType(
+      6
+      /* UInt64 */
+    ), this.count++, this.payload.writeBigUInt64(t);
+  }
+  writeFloat32(t) {
+    this.ensureElementType(
+      7
+      /* Float32 */
+    ), this.count++, this.payload.writeFloat32(t);
+  }
+  writeFloat64(t) {
+    this.ensureElementType(
+      8
+      /* Float64 */
+    ), this.count++, this.payload.writeFloat64(t);
+  }
+  writeBool(t) {
+    this.ensureElementType(
+      2
+      /* Bool */
+    ), this.count++, this.payload.writeByte(t ? 1 : 0);
+  }
+  writeGuid(t) {
+    this.ensureElementType(
+      14
+      /* Guid */
+    ), this.count++;
+    const r = t instanceof a ? t.asBytes() : t;
+    if (r.length !== 16)
+      throw new Error("Guid payload must be 16 bytes");
+    this.payload.writeBytes(r);
+  }
+  writeString(t) {
+    this.ensureElementType(
+      12
+      /* String */
+    ), this.count++;
+    const r = E.encode(t ?? "");
+    this.payload.writeVarUInt(r.length), this.payload.writeBytes(r);
+  }
+  writeBinary(t) {
+    this.ensureElementType(
+      13
+      /* Binary */
+    ), this.count++, this.payload.writeVarUInt(t.length), this.payload.writeBytes(t);
+  }
+  writeObject(t, r) {
+    this.ensureElementType(
+      11
+      /* Object */
+    ), this.count++;
+    const i = new y(t);
+    r(i);
+    const n = i.finish();
+    this.payload.writeVarUInt(n.length), this.payload.writeBytes(n);
+  }
+  writeArray(t, r) {
+    this.ensureElementType(
+      9
+      /* Array */
+    ), this.count++;
+    const i = new b(t);
+    r(i);
+    const n = i.finish();
+    this.payload.writeBytes(n);
+  }
+  writeDictionary(t, r, i) {
+    this.ensureElementType(
+      10
+      /* Dict */
+    ), this.count++;
+    const n = new _(t, r);
+    i(n);
+    const s = n.finish();
+    this.payload.writeBytes(s);
+  }
+  finish() {
+    const t = new p();
+    return t.writeByte(F(this.elementType)), t.writeVarUInt(this.count), t.writeBytes(this.payload.toUint8Array()), t.toUint8Array();
+  }
+  ensureElementType(t) {
+    if (this.elementType !== t)
+      throw new Error(`Array element type is ${w[this.elementType]}, expected ${w[t]}`);
+  }
+}
+class _ {
+  constructor(t, r) {
+    this.keyType = t, this.valueType = r, j(t);
+  }
+  payload = new p();
+  count = 0;
+  entryOpen = !1;
+  beginEntry() {
+    if (this.entryOpen)
+      throw new Error("Previous dictionary entry not completed");
+    return this.count++, this.entryOpen = !0, new H(this.keyType, this.valueType, this.payload, () => {
+      this.entryOpen = !1;
+    });
+  }
+  finish() {
+    if (this.entryOpen)
+      throw new Error("Dictionary entry not completed");
+    const t = new p();
+    return t.writeByte(F(this.keyType)), t.writeByte(F(this.valueType)), t.writeVarUInt(this.count), t.writeBytes(this.payload.toUint8Array()), t.toUint8Array();
+  }
+}
+class H {
+  constructor(t, r, i, n) {
+    this.keyType = t, this.valueType = r, this.payload = i, this.onComplete = n;
+  }
+  keyWritten = !1;
+  valueWritten = !1;
+  completed = !1;
+  writeKeyInt32(t) {
+    this.ensureKeyType(
+      3
+      /* Int32 */
+    ), this.payload.writeInt32(t | 0), this.keyWritten = !0;
+  }
+  writeKeyUInt32(t) {
+    this.ensureKeyType(
+      5
+      /* UInt32 */
+    ), this.payload.writeUInt32(t >>> 0), this.keyWritten = !0;
+  }
+  writeKeyInt64(t) {
+    this.ensureKeyType(
+      4
+      /* Int64 */
+    ), this.payload.writeBigInt64(t), this.keyWritten = !0;
+  }
+  writeKeyUInt64(t) {
+    this.ensureKeyType(
+      6
+      /* UInt64 */
+    ), this.payload.writeBigUInt64(t), this.keyWritten = !0;
+  }
+  writeKeyFloat32(t) {
+    this.ensureKeyType(
+      7
+      /* Float32 */
+    ), this.payload.writeFloat32(t), this.keyWritten = !0;
+  }
+  writeKeyFloat64(t) {
+    this.ensureKeyType(
+      8
+      /* Float64 */
+    ), this.payload.writeFloat64(t), this.keyWritten = !0;
+  }
+  writeKeyBool(t) {
+    this.ensureKeyType(
+      2
+      /* Bool */
+    ), this.payload.writeByte(t ? 1 : 0), this.keyWritten = !0;
+  }
+  writeKeyGuid(t) {
+    this.ensureKeyType(
+      14
+      /* Guid */
+    );
+    const r = t instanceof a ? t.asBytes() : t;
+    if (r.length !== 16)
+      throw new Error("Guid payload must be 16 bytes");
+    this.payload.writeBytes(r), this.keyWritten = !0;
+  }
+  writeKeyString(t) {
+    this.ensureKeyType(
+      12
+      /* String */
+    );
+    const r = E.encode(t ?? "");
+    this.payload.writeVarUInt(r.length), this.payload.writeBytes(r), this.keyWritten = !0;
+  }
+  writeKeyBinary(t) {
+    this.ensureKeyType(
+      13
+      /* Binary */
+    ), this.payload.writeVarUInt(t.length), this.payload.writeBytes(t), this.keyWritten = !0;
+  }
+  writeValueInt32(t) {
+    this.ensureValueType(
+      3
+      /* Int32 */
+    ), this.payload.writeInt32(t | 0), this.valueWritten = !0;
+  }
+  writeValueUInt32(t) {
+    this.ensureValueType(
+      5
+      /* UInt32 */
+    ), this.payload.writeUInt32(t >>> 0), this.valueWritten = !0;
+  }
+  writeValueInt64(t) {
+    this.ensureValueType(
+      4
+      /* Int64 */
+    ), this.payload.writeBigInt64(t), this.valueWritten = !0;
+  }
+  writeValueUInt64(t) {
+    this.ensureValueType(
+      6
+      /* UInt64 */
+    ), this.payload.writeBigUInt64(t), this.valueWritten = !0;
+  }
+  writeValueFloat32(t) {
+    this.ensureValueType(
+      7
+      /* Float32 */
+    ), this.payload.writeFloat32(t), this.valueWritten = !0;
+  }
+  writeValueFloat64(t) {
+    this.ensureValueType(
+      8
+      /* Float64 */
+    ), this.payload.writeFloat64(t), this.valueWritten = !0;
+  }
+  writeValueBool(t) {
+    this.ensureValueType(
+      2
+      /* Bool */
+    ), this.payload.writeByte(t ? 1 : 0), this.valueWritten = !0;
+  }
+  writeValueGuid(t) {
+    this.ensureValueType(
+      14
+      /* Guid */
+    );
+    const r = t instanceof a ? t.asBytes() : t;
+    if (r.length !== 16)
+      throw new Error("Guid payload must be 16 bytes");
+    this.payload.writeBytes(r), this.valueWritten = !0;
+  }
+  writeNullValue() {
+    this.ensureValueType(
+      1
+      /* Null */
+    ), this.valueWritten = !0;
+  }
+  writeValueBinary(t) {
+    this.ensureValueType(
+      13
+      /* Binary */
+    ), this.payload.writeVarUInt(t.length), this.payload.writeBytes(t), this.valueWritten = !0;
+  }
+  writeValueString(t) {
+    this.ensureValueType(
+      12
+      /* String */
+    );
+    const r = E.encode(t ?? "");
+    this.payload.writeVarUInt(r.length), this.payload.writeBytes(r), this.valueWritten = !0;
+  }
+  writeValueObject(t, r) {
+    this.ensureValueType(
+      11
+      /* Object */
+    );
+    const i = new y(t);
+    r(i);
+    const n = i.finish();
+    this.payload.writeVarUInt(n.length), this.payload.writeBytes(n), this.valueWritten = !0;
+  }
+  writeValueArray(t, r) {
+    this.ensureValueType(
+      9
+      /* Array */
+    );
+    const i = new b(t);
+    r(i);
+    const n = i.finish();
+    this.payload.writeBytes(n), this.valueWritten = !0;
+  }
+  writeValueDictionary(t, r, i) {
+    this.ensureValueType(
+      10
+      /* Dict */
+    );
+    const n = new _(t, r);
+    i(n);
+    const s = n.finish();
+    this.payload.writeBytes(s), this.valueWritten = !0;
+  }
+  complete() {
+    if (!this.completed) {
+      if (!this.keyWritten || !this.valueWritten)
+        throw new Error("Dictionary entry must write both key and value");
+      this.completed = !0, this.onComplete();
+    }
+  }
+  ensureKeyType(t) {
+    if (this.keyType !== t)
+      throw new Error(`Dictionary key type is ${w[this.keyType]}, expected ${w[t]}`);
+  }
+  ensureValueType(t) {
+    if (this.valueType !== t)
+      throw new Error(`Dictionary value type is ${w[this.valueType]}, expected ${w[t]}`);
+  }
+}
+class a {
+  constructor(t) {
+    this.bytes = t;
+  }
+  static fromString(t) {
+    if (!t)
+      throw new Error("Guid string is empty");
+    const r = t.replace(/-/g, "");
+    if (r.length !== 32)
+      throw new Error("Guid string must be 32 hex characters");
+    const i = new Uint8Array(16), n = a.parseHexSlice(r, 0, 8), s = a.parseHexSlice(r, 8, 4), o = a.parseHexSlice(r, 12, 4);
+    a.writeUInt32LE(i, 0, n), a.writeUInt16LE(i, 4, s), a.writeUInt16LE(i, 6, o);
+    for (let d = 0; d < 8; d++)
+      i[8 + d] = a.parseHexSlice(r, 16 + d * 2, 2);
+    return new a(i);
+  }
+  static fromBytes(t) {
+    if (t.length !== 16)
+      throw new Error("Guid byte array must be 16 bytes");
+    return new a(Uint8Array.from(t));
+  }
+  static createZero() {
+    return new a(new Uint8Array(16));
+  }
+  static createRandom() {
+    const t = new Uint8Array(16), r = globalThis.crypto;
+    if (r?.getRandomValues)
+      r.getRandomValues(t);
+    else
+      for (let i = 0; i < t.length; i++)
+        t[i] = Math.floor(Math.random() * 256);
+    return t[6] = t[6] & 15 | 64, t[8] = t[8] & 63 | 128, new a(t);
+  }
+  toString() {
+    const t = this.bytes;
+    return [
+      a.toHex(a.readUInt32LE(t, 0), 8),
+      a.toHex(a.readUInt16LE(t, 4), 4),
+      a.toHex(a.readUInt16LE(t, 6), 4),
+      R(t.subarray(8, 10)),
+      R(t.subarray(10, 16))
+    ].join("-");
+  }
+  asBytes() {
+    return this.bytes.slice();
+  }
+  static parseHexSlice(t, r, i) {
+    const n = t.substr(r, i), s = Number.parseInt(n, 16);
+    if (Number.isNaN(s))
+      throw new Error("Guid string contains invalid characters");
+    return s >>> 0;
+  }
+  static writeUInt32LE(t, r, i) {
+    const n = i >>> 0;
+    t[r] = n & 255, t[r + 1] = n >>> 8 & 255, t[r + 2] = n >>> 16 & 255, t[r + 3] = n >>> 24 & 255;
+  }
+  static writeUInt16LE(t, r, i) {
+    const n = i & 65535;
+    t[r] = n & 255, t[r + 1] = n >>> 8 & 255;
+  }
+  static readUInt32LE(t, r) {
+    return (t[r] | t[r + 1] << 8 | t[r + 2] << 16 | t[r + 3] << 24) >>> 0;
+  }
+  static readUInt16LE(t, r) {
+    return (t[r] | t[r + 1] << 8) & 65535;
+  }
+  static toHex(t, r) {
+    return (t >>> 0).toString(16).padStart(r, "0");
+  }
+}
+class p {
+  bytes = [];
+  writeByte(t) {
+    this.bytes.push(t & 255);
+  }
+  writeBytes(t) {
+    for (let r = 0; r < t.length; r++)
+      this.bytes.push(t[r]);
+  }
+  writeUInt32(t) {
+    this.bytes.push(t & 255), this.bytes.push(t >>> 8 & 255), this.bytes.push(t >>> 16 & 255), this.bytes.push(t >>> 24 & 255);
+  }
+  writeInt32(t) {
+    this.writeUInt32(t | 0);
+  }
+  writeFloat32(t) {
+    const r = new DataView(new ArrayBuffer(4));
+    r.setFloat32(0, t, !0), this.writeBytes(new Uint8Array(r.buffer));
+  }
+  writeFloat64(t) {
+    const r = new DataView(new ArrayBuffer(8));
+    r.setFloat64(0, t, !0), this.writeBytes(new Uint8Array(r.buffer));
+  }
+  writeBigInt64(t) {
+    const r = new DataView(new ArrayBuffer(8));
+    r.setBigInt64(0, t, !0), this.writeBytes(new Uint8Array(r.buffer));
+  }
+  writeBigUInt64(t) {
+    const r = new DataView(new ArrayBuffer(8));
+    r.setBigUint64(0, t, !0), this.writeBytes(new Uint8Array(r.buffer));
+  }
+  writeVarUInt(t) {
+    let r = t >>> 0;
+    for (; r >= 128; )
+      this.bytes.push(r & 127 | 128), r >>>= 7;
+    this.bytes.push(r & 127);
+  }
+  toUint8Array() {
+    return Uint8Array.from(this.bytes);
+  }
+}
+function F(e, t = 0) {
+  if ((t & 240) !== 0)
+    throw new Error("Teleport flags must fit into 4 bits");
+  return (e & 15) << 4 | t & 15;
+}
+function z(e) {
+  return e === 12 || e === 13 || e === 9 || e === 11 || e === 10;
+}
+function j(e) {
+  if (e === 9 || e === 11 || e === 10 || e === 1)
+    throw new Error("Dictionary keys must be primitive Teleport types");
+}
+function R(e) {
+  return Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
+}
+var S = /* @__PURE__ */ ((e) => (e[e.Unknown = 0] = "Unknown", e[e.Opus = 1] = "Opus", e[e.Mp3 = 2] = "Mp3", e[e.RawPcm16 = 3] = "RawPcm16", e))(S || {});
+const T = 1, $ = 4194307, G = 271275304, Y = 668699606, q = 945580544, J = 1594075008, Z = 2079085407, Q = 2541432218, X = 2986785889, tt = 3105403172, et = 4017217601;
+function rt(e) {
+  const t = {};
+  return it(t), e && Object.assign(t, e), t;
+}
+function it(e) {
+  return e.Data = new Uint8Array(0), e.IsKey = !1, e.IsLast = !1, e.TimestampInUs = 0n, e.DurationInUs = 0, e.IsFirst = !1, e.TotalDurationInUs = 0, e.Volume = 0, e.VolumeSampleCount = 0, e;
+}
+function nt(e) {
+  const t = new y(T);
+  return st(e, t), t.finish();
+}
+function st(e, t) {
+  t.writeUInt64Field(G, e.TimestampInUs), t.writeUInt32Field(Y, e.TotalDurationInUs >>> 0), t.writeInt32Field(q, e.VolumeSampleCount | 0), t.writeBoolField(J, e.IsFirst), t.writeFloat32Field(Z, e.Volume), t.writeUInt32Field(Q, e.DurationInUs >>> 0), t.writeBinaryField(X, e.Data), t.writeBoolField(tt, e.IsKey), t.writeBoolField(et, e.IsLast);
+}
+function at(e, t, r) {
+  const i = nt(e);
+  return U($, i, T, t, r);
+}
+const W = 1, ot = 4194308, ut = 2079085407, lt = 3485914759;
+function ct(e) {
+  const t = {};
+  return ht(t), e && Object.assign(t, e), t;
+}
+function ht(e) {
+  return e.Volume = 0, e.Count = 0, e;
+}
+function dt(e) {
+  const t = new y(W);
+  return yt(e, t), t.finish();
+}
+function yt(e, t) {
+  t.writeFloat32Field(ut, e.Volume), t.writeInt32Field(lt, e.Count | 0);
+}
+function wt(e, t, r) {
+  const i = dt(e);
+  return U(ot, i, W, t, r);
+}
+const k = 1, ft = 4194305, pt = 1368629611, It = 2431514951, mt = 2914494629, Et = 3284746250, Ft = 4101844078;
+function Ut(e) {
+  const t = {};
+  return bt(t), e && Object.assign(t, e), t;
+}
+function bt(e) {
+  return e.Description = "", e.Codec = S.Unknown, e.SampleRate = 0, e.Channels = 0, e.BitDepth = 0, e;
+}
+function At(e) {
+  const t = new y(k);
+  return gt(e, t), t.finish();
+}
+function gt(e, t) {
+  t.writeStringField(pt, e.Description), t.writeInt32Field(It, e.Channels | 0), t.writeInt32Field(mt, e.BitDepth | 0), t.writeInt32Field(Et, e.Codec), t.writeInt32Field(Ft, e.SampleRate | 0);
+}
+function Dt(e, t, r) {
+  const i = At(e);
+  return U(ft, i, k, t, r);
+}
+const v = 1, Bt = 4194306;
+function _t(e) {
+  const t = {};
+  return e && Object.assign(t, e), t;
+}
+function St(e) {
+  return new y(v).finish();
+}
+function Mt(e, t, r) {
+  const i = St();
+  return U(Bt, i, v, t, r);
+}
+class Vt {
+  static getStorageForCapacity(t, r) {
+    const i = Int32Array.BYTES_PER_ELEMENT * 2, n = r.BYTES_PER_ELEMENT * t;
+    return new SharedArrayBuffer(i + n);
+  }
+  readWrite;
+  storage;
+  buf;
+  constructor(t, r) {
+    this.buf = t, this.readWrite = new Int32Array(t, 0, 2);
+    const i = Int32Array.BYTES_PER_ELEMENT * 2, n = (t.byteLength - i) / Float32Array.BYTES_PER_ELEMENT;
+    this.storage = new r(t, i, n);
+  }
+  get capacity() {
+    return this.storage.length;
+  }
+  flush() {
+    Atomics.store(this.readWrite, 0, 0), Atomics.store(this.readWrite, 1, 0);
+  }
+  availableRead() {
+    const t = Atomics.load(this.readWrite, 0), r = Atomics.load(this.readWrite, 1);
+    return r >= t ? r - t : this.capacity - (t - r);
+  }
+  availableWrite() {
+    return this.capacity - this.availableRead() - 1;
+  }
+  push(t) {
+    const r = Math.min(this.availableWrite(), t.length);
+    if (r <= 0)
+      return 0;
+    let i = Atomics.load(this.readWrite, 1);
+    const n = Math.min(r, this.capacity - i);
+    this.storage.set(t.subarray(0, n), i);
+    const s = r - n;
+    return s > 0 && this.storage.set(t.subarray(n, n + s), 0), i = (i + r) % this.capacity, Atomics.store(this.readWrite, 1, i), Atomics.notify(this.readWrite, 1), r;
+  }
+  pop(t) {
+    const r = Math.min(this.availableRead(), t.length);
+    if (r <= 0)
+      return 0;
+    let i = Atomics.load(this.readWrite, 0);
+    const n = Math.min(r, this.capacity - i);
+    t.set(this.storage.subarray(i, i + n), 0);
+    const s = r - n;
+    return s > 0 && t.set(this.storage.subarray(0, s), n), i = (i + r) % this.capacity, Atomics.store(this.readWrite, 0, i), r;
+  }
+  skip(t) {
+    const r = Math.min(this.availableRead(), t);
+    if (r <= 0)
+      return 0;
+    let i = Atomics.load(this.readWrite, 0);
+    return i = (i + r) % this.capacity, Atomics.store(this.readWrite, 0, i), r;
+  }
+}
+let Ot = 1;
+function Lt(e, t) {
+  return `[${e}] ${t}`;
+}
+function m(e, t, r, i) {
+  if ((/* @__PURE__ */ new Date()).toISOString(), Ot <= e) {
+    const n = Lt(t, r);
+    switch (e) {
+      case 0:
+        console.debug(n, ...i);
+        break;
+      case 1:
+        console.info(n, ...i);
+        break;
+      case 2:
+        console.warn(n, ...i);
+        break;
+      case 3:
+        console.error(n, ...i);
+        break;
+    }
+  }
+}
+function Rt(e) {
+  return {
+    debug(t, ...r) {
+      m(0, e, t, r);
+    },
+    info(t, ...r) {
+      m(1, e, t, r);
+    },
+    warn(t, ...r) {
+      m(2, e, t, r);
+    },
+    error(t, ...r) {
+      m(3, e, t, r);
+    }
+  };
+}
+const Tt = Rt("AudioCaptureWorker"), M = (e) => self.postMessage(e);
+let l = null;
+function I(e, t) {
+  const r = e instanceof Error ? e : new Error(String(e));
+  M({ type: "error", captureId: t, error: { name: r.name, message: r.message, stack: r.stack } });
+}
+function Wt(e) {
+  return e.byteOffset === 0 && e.byteLength === e.buffer.byteLength ? e.buffer : e.slice().buffer;
+}
+function A(e) {
+  if (!l)
+    return;
+  const t = Wt(e);
+  l.postMessage({ type: "send", message: t }, [t]);
+}
+function kt(e) {
+  if (e.length === 0)
+    return 0;
+  let t = 0;
+  for (let r = 0; r < e.length; r++)
+    t += Math.abs(e[r] ?? 0);
+  return t / e.length;
+}
+const h = /* @__PURE__ */ new Map();
+let f = null;
+function vt() {
+  f === null && (f = self.setInterval(() => {
+    for (const e of h.values())
+      if (!(e.transport !== "sab" || !e.ringBuffer || !e.ringTemp || e.stopped))
+        try {
+          const t = e.ringBuffer.pop(e.ringTemp);
+          if (t <= 0)
+            continue;
+          const r = e.ringTemp.subarray(0, t);
+          x(e, new Float32Array(r));
+        } catch (t) {
+          I(t, e.captureId);
+        }
+  }, 10));
+}
+function Nt() {
+  if (!(f === null || Array.from(h.values()).some((t) => t.transport === "sab" && !t.stopped))) {
+    try {
+      self.clearInterval(f);
+    } catch {
+    }
+    f = null;
+  }
+}
+function N(e) {
+  if (!e.stopped)
+    for (; e.pendingSamples >= e.frameSize; ) {
+      const t = new Float32Array(e.frameSize);
+      let r = 0;
+      for (; r < e.frameSize && e.pending.length > 0; ) {
+        const n = e.pending[0], s = Math.min(n.length, e.frameSize - r);
+        t.set(n.subarray(0, s), r), r += s, s === n.length ? e.pending.shift() : e.pending[0] = n.subarray(s);
+      }
+      e.pendingSamples -= e.frameSize;
+      const i = kt(t);
+      A(wt(ct({ Volume: i, Count: e.frameSize }), e.senderId, { trackId: e.trackId }));
+      try {
+        const n = new AudioData({
+          format: "f32",
+          sampleRate: e.sampleRate,
+          numberOfFrames: e.frameSize,
+          numberOfChannels: e.channels,
+          timestamp: e.timestampUs,
+          data: t
+        });
+        e.encoder.encode(n), n.close();
+      } catch (n) {
+        I(n, e.captureId);
+      }
+      e.timestampUs += e.frameDurationUs;
+    }
+}
+function x(e, t) {
+  e.stopped || t.length !== 0 && (e.pending.push(t), e.pendingSamples += t.length, N(e));
+}
+function xt(e) {
+  const t = Math.max(8e3, Math.floor(e.options?.bitrate ?? 16e3)), r = new AudioEncoder({
+    output: (i) => {
+      const n = h.get(e.captureId);
+      if (!n || n.stopped)
+        return;
+      const s = new Uint8Array(i.byteLength);
+      i.copyTo(s);
+      const o = !n.sentFirst;
+      o && (n.sentFirst = !0), A(
+        at(
+          rt({
+            Data: s,
+            IsKey: i.type === "key",
+            IsFirst: o,
+            IsLast: !1,
+            TimestampInUs: BigInt(Math.max(0, Math.round(i.timestamp ?? n.timestampUs))),
+            DurationInUs: Math.max(0, Math.round(i.duration ?? n.frameDurationUs)),
+            TotalDurationInUs: 0
+          }),
+          n.senderId,
+          { trackId: n.trackId }
+        )
+      );
+    },
+    error: (i) => {
+      I(i, e.captureId);
+    }
+  });
+  return r.configure({
+    codec: "opus",
+    numberOfChannels: e.channels,
+    sampleRate: e.sampleRate,
+    bitrate: t,
+    bitrateMode: "constant",
+    opus: {
+      application: "lowdelay",
+      signal: "voice"
+    }
+  }), r;
+}
+function Pt(e) {
+  if (!l)
+    throw new Error("Audio capture worker missing send port");
+  if (h.has(e.captureId))
+    return;
+  if (typeof AudioEncoder > "u")
+    throw new Error("AudioEncoder is not available in this browser");
+  const t = Math.max(8e3, Math.floor(e.sampleRate)), r = Math.max(1, Math.floor(e.channels)), i = Math.max(10, Math.min(60, Math.floor(e.options?.frameDurationMs ?? 20))), n = Math.max(1, Math.floor(t * i / 1e3)), s = Math.max(1, Math.floor(n * 1e6 / t)), o = {
+    captureId: e.captureId,
+    senderId: e.senderId,
+    trackId: e.trackId,
+    sampleRate: t,
+    channels: r,
+    frameSize: n,
+    frameDurationUs: s,
+    timestampUs: 0,
+    sentFirst: !1,
+    stopped: !1,
+    transport: e.transport,
+    ringBuffer: null,
+    ringTemp: null,
+    pending: [],
+    pendingSamples: 0,
+    options: e.options
+  }, d = xt(o), c = {
+    ...o,
+    encoder: d
+  };
+  if (e.transport === "sab") {
+    if (!e.sharedArrayBuffer)
+      throw new Error("Missing SharedArrayBuffer for sab transport");
+    const g = new Vt(e.sharedArrayBuffer, Float32Array);
+    c.ringBuffer = g, c.ringTemp = new Float32Array(Math.max(c.frameSize * 4, 4096)), vt();
+  }
+  h.set(e.captureId, c), A(
+    Dt(
+      Ut({
+        Description: `mic:${e.captureId}`,
+        Codec: S.Opus,
+        SampleRate: t,
+        Channels: r,
+        BitDepth: 32
+      }),
+      e.senderId,
+      { trackId: e.trackId }
+    )
+  ), M({ type: "started", captureId: e.captureId, sampleRate: t, channels: r });
+}
+async function P(e) {
+  const t = h.get(e);
+  if (t) {
+    t.stopped = !0, h.delete(e);
+    try {
+      N(t);
+    } catch {
+    }
+    try {
+      await t.encoder.flush();
+    } catch {
+    }
+    try {
+      t.encoder.close();
+    } catch {
+    }
+    A(Mt(_t({}), t.senderId, { trackId: t.trackId })), M({ type: "stopped", captureId: e }), Nt();
+  }
+}
+function Ct() {
+  for (const e of Array.from(h.keys()))
+    P(e);
+  if (l) {
+    try {
+      l.close();
+    } catch {
+    }
+    l = null;
+  }
+}
+self.addEventListener("message", (e) => {
+  const t = e.data;
+  if (t.type === "attachSendPort") {
+    if (l)
+      try {
+        l.close();
+      } catch {
+      }
+    l = t.port;
+    try {
+      l.start?.();
+    } catch {
+    }
+    return;
+  }
+  if (t.type === "start") {
+    try {
+      Pt(t);
+    } catch (r) {
+      I(r, t.captureId);
+    }
+    return;
+  }
+  if (t.type === "pcm") {
+    const r = h.get(t.captureId);
+    if (!r || r.stopped)
+      return;
+    x(r, t.pcm);
+    return;
+  }
+  if (t.type === "stop") {
+    P(t.captureId).catch((r) => {
+      Tt.warn(`Failed to stop audio capture: ${r}`), I(r, t.captureId);
+    });
+    return;
+  }
+  t.type === "dispose" && Ct();
+});