@ikonai/sdk-ui 1.0.58 → 1.0.60

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

@@ -0,0 +1,1279 @@
+function L(t, e, r, n, i) {
+  const s = i?.trackId ?? 0, a = i?.sequenceId ?? 0, c = i?.flags ?? 0, d = i?.targetIds ?? [], o = i?.payloadType ?? 8, h = 27 + d.length * 4, y = h + e.length, u = new Uint8Array(y), f = new DataView(u.buffer);
+  f.setUint32(0, y, !0), f.setUint32(4, t >>> 0, !0), f.setUint32(8, n >>> 0, !0), f.setUint32(12, s >>> 0, !0), f.setUint32(16, a >>> 0, !0), f.setUint32(20, d.length >>> 0, !0), f.setUint8(24, r & 255), f.setUint8(25, o & 255), f.setUint8(26, c & 255);
+  let N = 27;
+  for (let V = 0; V < d.length; V++)
+    f.setUint32(N, d[V] >>> 0, !0), N += 4;
+  return u.set(e, h), u;
+}
+var m = /* @__PURE__ */ ((t) => (t[t.Null = 1] = "Null", t[t.Bool = 2] = "Bool", t[t.Int32 = 3] = "Int32", t[t.Int64 = 4] = "Int64", t[t.UInt32 = 5] = "UInt32", t[t.UInt64 = 6] = "UInt64", t[t.Float32 = 7] = "Float32", t[t.Float64 = 8] = "Float64", t[t.Array = 9] = "Array", t[t.Dict = 10] = "Dict", t[t.Object = 11] = "Object", t[t.String = 12] = "String", t[t.Binary = 13] = "Binary", t[t.Guid = 14] = "Guid", t))(m || {});
+const q = 161, G = 162, _ = new TextEncoder();
+new TextDecoder("utf-8", { fatal: !0 });
+class S {
+  constructor(e = 1) {
+    this.version = e, this.buffer.writeByte(q), this.buffer.writeVarUInt(e >>> 0);
+  }
+  buffer = new E();
+  closed = !1;
+  cached;
+  writeInt32Field(e, r) {
+    this.writeFixedField(e, 3, () => this.buffer.writeInt32(r | 0));
+  }
+  writeUInt32Field(e, r) {
+    this.writeFixedField(e, 5, () => this.buffer.writeUInt32(r >>> 0));
+  }
+  writeInt64Field(e, r) {
+    this.writeFixedField(e, 4, () => this.buffer.writeBigInt64(r));
+  }
+  writeUInt64Field(e, r) {
+    this.writeFixedField(e, 6, () => this.buffer.writeBigUInt64(r));
+  }
+  writeFloat32Field(e, r) {
+    this.writeFixedField(e, 7, () => this.buffer.writeFloat32(r));
+  }
+  writeFloat64Field(e, r) {
+    this.writeFixedField(e, 8, () => this.buffer.writeFloat64(r));
+  }
+  writeBoolField(e, r) {
+    this.writeFixedField(e, 2, () => this.buffer.writeByte(r ? 1 : 0));
+  }
+  writeGuidField(e, r) {
+    const n = r instanceof l ? r.asBytes() : r;
+    if (n.length !== 16)
+      throw new Error("Guid payload must be 16 bytes");
+    this.writeFixedField(e, 14, () => this.buffer.writeBytes(n));
+  }
+  writeStringField(e, r) {
+    const n = _.encode(r ?? "");
+    this.writeVariableField(e, 12, n);
+  }
+  writeBinaryField(e, r) {
+    this.writeVariableField(e, 13, r);
+  }
+  writeObjectField(e, r, n) {
+    const i = new S(r);
+    n(i);
+    const s = i.finish();
+    this.writeVariableField(e, 11, s);
+  }
+  writeArrayField(e, r, n) {
+    const i = new R(r);
+    n(i);
+    const s = i.finish();
+    this.writeVariableField(e, 9, s);
+  }
+  writeDictionaryField(e, r, n, i) {
+    const s = new W(r, n);
+    i(s);
+    const a = s.finish();
+    this.writeVariableField(e, 10, a);
+  }
+  finish() {
+    return this.closed || (this.buffer.writeByte(G), this.closed = !0, this.cached = this.buffer.toUint8Array()), this.cached;
+  }
+  writeFixedField(e, r, n) {
+    this.writeFieldHeader(e, r, 0), n();
+  }
+  writeVariableField(e, r, n) {
+    this.writeFieldHeader(e, r, n.length), this.buffer.writeBytes(n);
+  }
+  writeFieldHeader(e, r, n) {
+    this.buffer.writeUInt32(e >>> 0), this.buffer.writeByte(B(r)), J(r) && this.buffer.writeVarUInt(n >>> 0);
+  }
+}
+class R {
+  constructor(e) {
+    this.elementType = e;
+  }
+  payload = new E();
+  count = 0;
+  writeInt32(e) {
+    this.ensureElementType(
+      3
+      /* Int32 */
+    ), this.count++, this.payload.writeInt32(e | 0);
+  }
+  writeUInt32(e) {
+    this.ensureElementType(
+      5
+      /* UInt32 */
+    ), this.count++, this.payload.writeUInt32(e >>> 0);
+  }
+  writeInt64(e) {
+    this.ensureElementType(
+      4
+      /* Int64 */
+    ), this.count++, this.payload.writeBigInt64(e);
+  }
+  writeUInt64(e) {
+    this.ensureElementType(
+      6
+      /* UInt64 */
+    ), this.count++, this.payload.writeBigUInt64(e);
+  }
+  writeFloat32(e) {
+    this.ensureElementType(
+      7
+      /* Float32 */
+    ), this.count++, this.payload.writeFloat32(e);
+  }
+  writeFloat64(e) {
+    this.ensureElementType(
+      8
+      /* Float64 */
+    ), this.count++, this.payload.writeFloat64(e);
+  }
+  writeBool(e) {
+    this.ensureElementType(
+      2
+      /* Bool */
+    ), this.count++, this.payload.writeByte(e ? 1 : 0);
+  }
+  writeGuid(e) {
+    this.ensureElementType(
+      14
+      /* Guid */
+    ), this.count++;
+    const r = e instanceof l ? e.asBytes() : e;
+    if (r.length !== 16)
+      throw new Error("Guid payload must be 16 bytes");
+    this.payload.writeBytes(r);
+  }
+  writeString(e) {
+    this.ensureElementType(
+      12
+      /* String */
+    ), this.count++;
+    const r = _.encode(e ?? "");
+    this.payload.writeVarUInt(r.length), this.payload.writeBytes(r);
+  }
+  writeBinary(e) {
+    this.ensureElementType(
+      13
+      /* Binary */
+    ), this.count++, this.payload.writeVarUInt(e.length), this.payload.writeBytes(e);
+  }
+  writeObject(e, r) {
+    this.ensureElementType(
+      11
+      /* Object */
+    ), this.count++;
+    const n = new S(e);
+    r(n);
+    const i = n.finish();
+    this.payload.writeVarUInt(i.length), this.payload.writeBytes(i);
+  }
+  writeArray(e, r) {
+    this.ensureElementType(
+      9
+      /* Array */
+    ), this.count++;
+    const n = new R(e);
+    r(n);
+    const i = n.finish();
+    this.payload.writeBytes(i);
+  }
+  writeDictionary(e, r, n) {
+    this.ensureElementType(
+      10
+      /* Dict */
+    ), this.count++;
+    const i = new W(e, r);
+    n(i);
+    const s = i.finish();
+    this.payload.writeBytes(s);
+  }
+  finish() {
+    const e = new E();
+    return e.writeByte(B(this.elementType)), e.writeVarUInt(this.count), e.writeBytes(this.payload.toUint8Array()), e.toUint8Array();
+  }
+  ensureElementType(e) {
+    if (this.elementType !== e)
+      throw new Error(`Array element type is ${m[this.elementType]}, expected ${m[e]}`);
+  }
+}
+class W {
+  constructor(e, r) {
+    this.keyType = e, this.valueType = r, X(e);
+  }
+  payload = new E();
+  count = 0;
+  entryOpen = !1;
+  beginEntry() {
+    if (this.entryOpen)
+      throw new Error("Previous dictionary entry not completed");
+    return this.count++, this.entryOpen = !0, new Y(this.keyType, this.valueType, this.payload, () => {
+      this.entryOpen = !1;
+    });
+  }
+  finish() {
+    if (this.entryOpen)
+      throw new Error("Dictionary entry not completed");
+    const e = new E();
+    return e.writeByte(B(this.keyType)), e.writeByte(B(this.valueType)), e.writeVarUInt(this.count), e.writeBytes(this.payload.toUint8Array()), e.toUint8Array();
+  }
+}
+class Y {
+  constructor(e, r, n, i) {
+    this.keyType = e, this.valueType = r, this.payload = n, this.onComplete = i;
+  }
+  keyWritten = !1;
+  valueWritten = !1;
+  completed = !1;
+  writeKeyInt32(e) {
+    this.ensureKeyType(
+      3
+      /* Int32 */
+    ), this.payload.writeInt32(e | 0), this.keyWritten = !0;
+  }
+  writeKeyUInt32(e) {
+    this.ensureKeyType(
+      5
+      /* UInt32 */
+    ), this.payload.writeUInt32(e >>> 0), this.keyWritten = !0;
+  }
+  writeKeyInt64(e) {
+    this.ensureKeyType(
+      4
+      /* Int64 */
+    ), this.payload.writeBigInt64(e), this.keyWritten = !0;
+  }
+  writeKeyUInt64(e) {
+    this.ensureKeyType(
+      6
+      /* UInt64 */
+    ), this.payload.writeBigUInt64(e), this.keyWritten = !0;
+  }
+  writeKeyFloat32(e) {
+    this.ensureKeyType(
+      7
+      /* Float32 */
+    ), this.payload.writeFloat32(e), this.keyWritten = !0;
+  }
+  writeKeyFloat64(e) {
+    this.ensureKeyType(
+      8
+      /* Float64 */
+    ), this.payload.writeFloat64(e), this.keyWritten = !0;
+  }
+  writeKeyBool(e) {
+    this.ensureKeyType(
+      2
+      /* Bool */
+    ), this.payload.writeByte(e ? 1 : 0), this.keyWritten = !0;
+  }
+  writeKeyGuid(e) {
+    this.ensureKeyType(
+      14
+      /* Guid */
+    );
+    const r = e instanceof l ? e.asBytes() : e;
+    if (r.length !== 16)
+      throw new Error("Guid payload must be 16 bytes");
+    this.payload.writeBytes(r), this.keyWritten = !0;
+  }
+  writeKeyString(e) {
+    this.ensureKeyType(
+      12
+      /* String */
+    );
+    const r = _.encode(e ?? "");
+    this.payload.writeVarUInt(r.length), this.payload.writeBytes(r), this.keyWritten = !0;
+  }
+  writeKeyBinary(e) {
+    this.ensureKeyType(
+      13
+      /* Binary */
+    ), this.payload.writeVarUInt(e.length), this.payload.writeBytes(e), this.keyWritten = !0;
+  }
+  writeValueInt32(e) {
+    this.ensureValueType(
+      3
+      /* Int32 */
+    ), this.payload.writeInt32(e | 0), this.valueWritten = !0;
+  }
+  writeValueUInt32(e) {
+    this.ensureValueType(
+      5
+      /* UInt32 */
+    ), this.payload.writeUInt32(e >>> 0), this.valueWritten = !0;
+  }
+  writeValueInt64(e) {
+    this.ensureValueType(
+      4
+      /* Int64 */
+    ), this.payload.writeBigInt64(e), this.valueWritten = !0;
+  }
+  writeValueUInt64(e) {
+    this.ensureValueType(
+      6
+      /* UInt64 */
+    ), this.payload.writeBigUInt64(e), this.valueWritten = !0;
+  }
+  writeValueFloat32(e) {
+    this.ensureValueType(
+      7
+      /* Float32 */
+    ), this.payload.writeFloat32(e), this.valueWritten = !0;
+  }
+  writeValueFloat64(e) {
+    this.ensureValueType(
+      8
+      /* Float64 */
+    ), this.payload.writeFloat64(e), this.valueWritten = !0;
+  }
+  writeValueBool(e) {
+    this.ensureValueType(
+      2
+      /* Bool */
+    ), this.payload.writeByte(e ? 1 : 0), this.valueWritten = !0;
+  }
+  writeValueGuid(e) {
+    this.ensureValueType(
+      14
+      /* Guid */
+    );
+    const r = e instanceof l ? e.asBytes() : e;
+    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(e) {
+    this.ensureValueType(
+      13
+      /* Binary */
+    ), this.payload.writeVarUInt(e.length), this.payload.writeBytes(e), this.valueWritten = !0;
+  }
+  writeValueString(e) {
+    this.ensureValueType(
+      12
+      /* String */
+    );
+    const r = _.encode(e ?? "");
+    this.payload.writeVarUInt(r.length), this.payload.writeBytes(r), this.valueWritten = !0;
+  }
+  writeValueObject(e, r) {
+    this.ensureValueType(
+      11
+      /* Object */
+    );
+    const n = new S(e);
+    r(n);
+    const i = n.finish();
+    this.payload.writeVarUInt(i.length), this.payload.writeBytes(i), this.valueWritten = !0;
+  }
+  writeValueArray(e, r) {
+    this.ensureValueType(
+      9
+      /* Array */
+    );
+    const n = new R(e);
+    r(n);
+    const i = n.finish();
+    this.payload.writeBytes(i), this.valueWritten = !0;
+  }
+  writeValueDictionary(e, r, n) {
+    this.ensureValueType(
+      10
+      /* Dict */
+    );
+    const i = new W(e, r);
+    n(i);
+    const s = i.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(e) {
+    if (this.keyType !== e)
+      throw new Error(`Dictionary key type is ${m[this.keyType]}, expected ${m[e]}`);
+  }
+  ensureValueType(e) {
+    if (this.valueType !== e)
+      throw new Error(`Dictionary value type is ${m[this.valueType]}, expected ${m[e]}`);
+  }
+}
+class l {
+  constructor(e) {
+    this.bytes = e;
+  }
+  static fromString(e) {
+    if (!e)
+      throw new Error("Guid string is empty");
+    const r = e.replace(/-/g, "");
+    if (r.length !== 32)
+      throw new Error("Guid string must be 32 hex characters");
+    const n = new Uint8Array(16), i = l.parseHexSlice(r, 0, 8), s = l.parseHexSlice(r, 8, 4), a = l.parseHexSlice(r, 12, 4);
+    l.writeUInt32LE(n, 0, i), l.writeUInt16LE(n, 4, s), l.writeUInt16LE(n, 6, a);
+    for (let c = 0; c < 8; c++)
+      n[8 + c] = l.parseHexSlice(r, 16 + c * 2, 2);
+    return new l(n);
+  }
+  static fromBytes(e) {
+    if (e.length !== 16)
+      throw new Error("Guid byte array must be 16 bytes");
+    return new l(Uint8Array.from(e));
+  }
+  static createZero() {
+    return new l(new Uint8Array(16));
+  }
+  static createRandom() {
+    const e = new Uint8Array(16), r = globalThis.crypto;
+    if (r?.getRandomValues)
+      r.getRandomValues(e);
+    else
+      for (let n = 0; n < e.length; n++)
+        e[n] = Math.floor(Math.random() * 256);
+    return e[6] = e[6] & 15 | 64, e[8] = e[8] & 63 | 128, new l(e);
+  }
+  toString() {
+    const e = this.bytes;
+    return [
+      l.toHex(l.readUInt32LE(e, 0), 8),
+      l.toHex(l.readUInt16LE(e, 4), 4),
+      l.toHex(l.readUInt16LE(e, 6), 4),
+      k(e.subarray(8, 10)),
+      k(e.subarray(10, 16))
+    ].join("-");
+  }
+  asBytes() {
+    return this.bytes.slice();
+  }
+  static parseHexSlice(e, r, n) {
+    const i = e.substr(r, n), s = Number.parseInt(i, 16);
+    if (Number.isNaN(s))
+      throw new Error("Guid string contains invalid characters");
+    return s >>> 0;
+  }
+  static writeUInt32LE(e, r, n) {
+    const i = n >>> 0;
+    e[r] = i & 255, e[r + 1] = i >>> 8 & 255, e[r + 2] = i >>> 16 & 255, e[r + 3] = i >>> 24 & 255;
+  }
+  static writeUInt16LE(e, r, n) {
+    const i = n & 65535;
+    e[r] = i & 255, e[r + 1] = i >>> 8 & 255;
+  }
+  static readUInt32LE(e, r) {
+    return (e[r] | e[r + 1] << 8 | e[r + 2] << 16 | e[r + 3] << 24) >>> 0;
+  }
+  static readUInt16LE(e, r) {
+    return (e[r] | e[r + 1] << 8) & 65535;
+  }
+  static toHex(e, r) {
+    return (e >>> 0).toString(16).padStart(r, "0");
+  }
+}
+class E {
+  static INITIAL_CAPACITY = 256;
+  buffer;
+  dataView;
+  length = 0;
+  constructor() {
+    this.buffer = new Uint8Array(E.INITIAL_CAPACITY), this.dataView = new DataView(this.buffer.buffer);
+  }
+  ensureCapacity(e) {
+    const r = this.length + e;
+    if (r <= this.buffer.length)
+      return;
+    let n = this.buffer.length;
+    for (; n < r; )
+      n *= 2;
+    const i = new Uint8Array(n);
+    i.set(this.buffer.subarray(0, this.length)), this.buffer = i, this.dataView = new DataView(this.buffer.buffer);
+  }
+  writeByte(e) {
+    this.ensureCapacity(1), this.buffer[this.length++] = e & 255;
+  }
+  writeBytes(e) {
+    this.ensureCapacity(e.length), this.buffer.set(e, this.length), this.length += e.length;
+  }
+  writeUInt32(e) {
+    this.ensureCapacity(4), this.dataView.setUint32(this.length, e >>> 0, !0), this.length += 4;
+  }
+  writeInt32(e) {
+    this.ensureCapacity(4), this.dataView.setInt32(this.length, e | 0, !0), this.length += 4;
+  }
+  writeFloat32(e) {
+    this.ensureCapacity(4), this.dataView.setFloat32(this.length, e, !0), this.length += 4;
+  }
+  writeFloat64(e) {
+    this.ensureCapacity(8), this.dataView.setFloat64(this.length, e, !0), this.length += 8;
+  }
+  writeBigInt64(e) {
+    this.ensureCapacity(8), this.dataView.setBigInt64(this.length, e, !0), this.length += 8;
+  }
+  writeBigUInt64(e) {
+    this.ensureCapacity(8), this.dataView.setBigUint64(this.length, e, !0), this.length += 8;
+  }
+  writeVarUInt(e) {
+    let r = e >>> 0;
+    for (; r >= 128; )
+      this.ensureCapacity(1), this.buffer[this.length++] = r & 127 | 128, r >>>= 7;
+    this.ensureCapacity(1), this.buffer[this.length++] = r & 127;
+  }
+  toUint8Array() {
+    return this.buffer.slice(0, this.length);
+  }
+}
+function B(t, e = 0) {
+  if ((e & 240) !== 0)
+    throw new Error("Teleport flags must fit into 4 bits");
+  return (t & 15) << 4 | e & 15;
+}
+function J(t) {
+  return t === 12 || t === 13 || t === 9 || t === 11 || t === 10;
+}
+function X(t) {
+  if (t === 9 || t === 11 || t === 10 || t === 1)
+    throw new Error("Dictionary keys must be primitive Teleport types");
+}
+function k(t) {
+  return Array.from(t).map((e) => e.toString(16).padStart(2, "0")).join("");
+}
+var P = /* @__PURE__ */ ((t) => (t[t.Unknown = 0] = "Unknown", t[t.Opus = 1] = "Opus", t[t.Mp3 = 2] = "Mp3", t[t.RawPcm16 = 3] = "RawPcm16", t))(P || {});
+const z = 1, Z = 4194309, Q = 205938238, ee = 1594075008, te = 2026534360, re = 3409001585, ne = 3466650495, ie = 4007456593, se = 4017217601, ae = 4065417427, oe = 4086360332;
+function ce(t) {
+  const e = {};
+  return ue(e), t && Object.assign(e, t), e;
+}
+function ue(t) {
+  return t.Samples = new Uint8Array(0), t.Epoch = 0, t.Sequence = 0, t.FrameSizeInInterleavedSamples = 0, t.TimeStampInInterleavedSamples = 0n, t.IsFirst = !1, t.IsLast = !1, t.AverageVolume = 0, t.AudioEventEstimatedDuration = 0, t;
+}
+function le(t) {
+  const e = new S(z);
+  return de(t, e), e.finish();
+}
+function de(t, e) {
+  e.writeFloat32Field(Q, t.AverageVolume), e.writeBoolField(ee, t.IsFirst), e.writeUInt64Field(te, t.TimeStampInInterleavedSamples), e.writeBinaryField(re, t.Samples), e.writeFloat32Field(ne, t.AudioEventEstimatedDuration), e.writeUInt32Field(ie, t.FrameSizeInInterleavedSamples >>> 0), e.writeBoolField(se, t.IsLast), e.writeUInt32Field(ae, t.Sequence >>> 0), e.writeUInt32Field(oe, t.Epoch >>> 0);
+}
+function he(t, e, r) {
+  const n = le(t);
+  return L(Z, n, z, e, r);
+}
+const H = 6, fe = 4194305, pe = 161083277, ye = 265814330, we = 1368629611, Ie = 2431514951, me = 2514959030, ge = 2745379226, Ee = 3282782683, Se = 3284746250, Ae = 4101844078;
+function be(t) {
+  const e = {};
+  return Fe(e), t && Object.assign(e, t), e;
+}
+function Fe(t) {
+  return t.StreamId = "", t.Description = "", t.SourceType = "", t.Codec = P.Unknown, t.CodecDetails = "", t.SampleRate = 0, t.Channels = 0, t.ShapeSets = void 0, t.CorrelationId = void 0, t;
+}
+function Ue(t) {
+  const e = new S(H);
+  return _e(t, e), e.finish();
+}
+function _e(t, e) {
+  e.writeStringField(pe, t.StreamId);
+  const r = t.ShapeSets;
+  r != null && e.writeArrayField(ye, m.Object, (i) => {
+    for (const s of r)
+      i.writeObject(Oe, (a) => {
+        Te(s, a);
+      });
+  }), e.writeStringField(we, t.Description), e.writeInt32Field(Ie, t.Channels | 0);
+  const n = t.CorrelationId;
+  n != null && e.writeStringField(me, n), e.writeStringField(ge, t.CodecDetails), e.writeStringField(Ee, t.SourceType), e.writeInt32Field(Se, t.Codec), e.writeInt32Field(Ae, t.SampleRate | 0);
+}
+function Be(t, e, r) {
+  const n = Ue(t);
+  return L(fe, n, H, e, r);
+}
+const Oe = 6, De = 1107713536, Re = 1154362099, Me = 1185721362;
+function Te(t, e) {
+  e.writeStringField(De, t.Name), e.writeUInt32Field(Re, t.SetId >>> 0), e.writeArrayField(Me, m.String, (r) => {
+    for (const n of t.ShapeNames)
+      r.writeString(n);
+  });
+}
+const K = 1, Ve = 4194306;
+function Le(t) {
+  const e = {};
+  return t && Object.assign(e, t), e;
+}
+function We(t) {
+  return new S(K).finish();
+}
+function Pe(t, e, r) {
+  const n = We();
+  return L(Ve, n, K, e, r);
+}
+class Ce {
+  static getStorageForCapacity(e, r) {
+    const n = Int32Array.BYTES_PER_ELEMENT * 2, i = r.BYTES_PER_ELEMENT * e;
+    return new SharedArrayBuffer(n + i);
+  }
+  readWrite;
+  storage;
+  buf;
+  constructor(e, r) {
+    this.buf = e, this.readWrite = new Int32Array(e, 0, 2);
+    const n = Int32Array.BYTES_PER_ELEMENT * 2, i = (e.byteLength - n) / Float32Array.BYTES_PER_ELEMENT;
+    this.storage = new r(e, n, i);
+  }
+  get capacity() {
+    return this.storage.length;
+  }
+  flush() {
+    Atomics.store(this.readWrite, 0, 0), Atomics.store(this.readWrite, 1, 0);
+  }
+  availableRead() {
+    const e = Atomics.load(this.readWrite, 0), r = Atomics.load(this.readWrite, 1);
+    return r >= e ? r - e : this.capacity - (e - r);
+  }
+  availableWrite() {
+    return this.capacity - this.availableRead() - 1;
+  }
+  push(e) {
+    const r = Math.min(this.availableWrite(), e.length);
+    if (r <= 0)
+      return 0;
+    let n = Atomics.load(this.readWrite, 1);
+    const i = Math.min(r, this.capacity - n);
+    this.storage.set(e.subarray(0, i), n);
+    const s = r - i;
+    return s > 0 && this.storage.set(e.subarray(i, i + s), 0), n = (n + r) % this.capacity, Atomics.store(this.readWrite, 1, n), Atomics.notify(this.readWrite, 1), r;
+  }
+  pop(e) {
+    const r = Math.min(this.availableRead(), e.length);
+    if (r <= 0)
+      return 0;
+    let n = Atomics.load(this.readWrite, 0);
+    const i = Math.min(r, this.capacity - n);
+    e.set(this.storage.subarray(n, n + i), 0);
+    const s = r - i;
+    return s > 0 && e.set(this.storage.subarray(0, s), i), n = (n + r) % this.capacity, Atomics.store(this.readWrite, 0, n), r;
+  }
+  skip(e) {
+    const r = Math.min(this.availableRead(), e);
+    if (r <= 0)
+      return 0;
+    let n = Atomics.load(this.readWrite, 0);
+    return n = (n + r) % this.capacity, Atomics.store(this.readWrite, 0, n), r;
+  }
+}
+let ve = 1;
+const Ne = /* @__PURE__ */ new Map(), ke = {
+  0: "DEBUG",
+  1: "INFO",
+  2: "WARN",
+  3: "ERROR",
+  4: "NONE"
+};
+function xe(t, e) {
+  return `[${t}] ${e}`;
+}
+function F(t, e, r, n) {
+  const i = (/* @__PURE__ */ new Date()).toISOString(), s = ke[t], a = {
+    timestamp: i,
+    level: t,
+    levelName: s,
+    component: e,
+    message: r,
+    args: n
+  };
+  for (const [c, d] of Ne) {
+    const o = d?.minLevel ?? 2;
+    if (t >= o)
+      try {
+        c(a);
+      } catch {
+      }
+  }
+  if (ve <= t) {
+    const c = xe(e, r);
+    switch (t) {
+      case 0:
+        console.debug(c, ...n);
+        break;
+      case 1:
+        console.info(c, ...n);
+        break;
+      case 2:
+        console.warn(c, ...n);
+        break;
+      case 3:
+        console.error(c, ...n);
+        break;
+    }
+  }
+}
+function ze(t) {
+  return {
+    debug(e, ...r) {
+      F(0, t, e, r);
+    },
+    info(e, ...r) {
+      F(1, t, e, r);
+    },
+    warn(e, ...r) {
+      F(2, t, e, r);
+    },
+    error(e, ...r) {
+      F(3, t, e, r);
+    }
+  };
+}
+const He = 20, b = 32e3, Ke = 5, M = 8e3, g = ze("AudioCaptureWorker");
+class $ {
+  encoder = null;
+  isReady = !1;
+  sampleRate;
+  channels;
+  bitrate;
+  frameSize;
+  onOutput;
+  onError;
+  timestampUs = 0;
+  frameDurationUs;
+  constructor(e) {
+    this.sampleRate = e.sampleRate, this.channels = e.channels, this.bitrate = e.bitrate, this.frameSize = e.frameSize, this.frameDurationUs = Math.floor(this.frameSize * 1e6 / this.sampleRate), this.onOutput = e.onOutput, this.onError = e.onError;
+  }
+  async initialize() {
+    try {
+      const { OpusEncoder: e, OPUS_APPLICATION_VOIP: r, getOpusModule: n } = await import("./index-D_vz6N3U.js");
+      await n(), this.encoder = new e({
+        sampleRate: this.sampleRate,
+        channels: this.channels,
+        bitrate: this.bitrate,
+        application: r,
+        complexity: Ke
+      }), await this.encoder.ready, this.isReady = !0;
+    } catch (e) {
+      this.onError(e instanceof Error ? e : new Error(String(e)));
+    }
+  }
+  encode(e) {
+    if (!(!this.isReady || !this.encoder))
+      try {
+        let r;
+        if (e instanceof Float32Array)
+          r = e;
+        else {
+          const i = e.numberOfFrames, s = e.numberOfChannels;
+          r = new Float32Array(i * s), e.copyTo(r, { planeIndex: 0, format: "f32" }), e.close();
+        }
+        const n = this.encoder.encodeAndCopy(r);
+        this.onOutput(n, this.timestampUs, this.frameDurationUs), this.timestampUs += this.frameDurationUs;
+      } catch (r) {
+        this.onError(r instanceof Error ? r : new Error(String(r)));
+      }
+  }
+  async flush() {
+  }
+  close() {
+    try {
+      this.encoder?.destroy();
+    } catch {
+    }
+    this.encoder = null, this.isReady = !1;
+  }
+  getBitrate() {
+    return this.bitrate;
+  }
+}
+const O = (t) => self.postMessage(t);
+let I = null;
+function w(t, e) {
+  const r = t instanceof Error ? t : new Error(String(t));
+  O({ type: "error", captureId: e, error: { name: r.name, message: r.message, stack: r.stack } });
+}
+function $e(t) {
+  return t.byteOffset === 0 && t.byteLength === t.buffer.byteLength ? t.buffer : t.slice().buffer;
+}
+function C(t) {
+  if (!I) {
+    g.warn("Audio capture message dropped: sendPort not available");
+    return;
+  }
+  const e = $e(t);
+  I.postMessage({ type: "send", message: e }, [e]);
+}
+function je(t) {
+  if (t.length === 0)
+    return 0;
+  let e = 0;
+  for (let r = 0; r < t.length; r++)
+    e += Math.abs(t[r] ?? 0);
+  return e / t.length;
+}
+const p = /* @__PURE__ */ new Map(), U = /* @__PURE__ */ new Map();
+let A = null;
+const x = 1;
+function qe() {
+  return typeof Atomics < "u" && typeof Atomics.waitAsync == "function";
+}
+async function Ge(t) {
+  if (!t.ringBuffer || !t.ringTemp)
+    return;
+  const e = t.ringBuffer, r = t.ringTemp;
+  for (; !t.stopped && t.transport === "sab"; ) {
+    try {
+      const n = e.pop(r);
+      n > 0 && T(t, r.subarray(0, n));
+    } catch (n) {
+      w(n, t.captureId);
+    }
+    try {
+      const n = Atomics.load(e.readWrite, x), i = Atomics.waitAsync(e.readWrite, x, n, 100);
+      i.async && await i.value;
+    } catch {
+      await new Promise((n) => setTimeout(n, 10));
+    }
+  }
+}
+function Ye() {
+  for (const t of p.values())
+    if (!(t.transport !== "sab" || !t.ringBuffer || !t.ringTemp || t.stopped))
+      try {
+        const e = t.ringBuffer.pop(t.ringTemp);
+        e > 0 && T(t, t.ringTemp.subarray(0, e));
+      } catch (e) {
+        w(e, t.captureId);
+      }
+}
+function Je(t) {
+  if (qe()) {
+    if (!U.has(t.captureId)) {
+      const e = Ge(t);
+      U.set(t.captureId, e), e.finally(() => {
+        U.delete(t.captureId);
+      });
+    }
+  } else
+    A === null && (A = self.setInterval(Ye, 50));
+}
+function Xe(t) {
+  if (U.delete(t), A !== null) {
+    let e = !1;
+    for (const r of p.values())
+      if (r.transport === "sab" && !r.stopped) {
+        e = !0;
+        break;
+      }
+    if (!e) {
+      try {
+        self.clearInterval(A);
+      } catch {
+      }
+      A = null;
+    }
+  }
+}
+function v(t) {
+  if (t.stopped || t.isReconfiguring)
+    return;
+  if (!t.inSegment) {
+    t.pendingReadOffset = 0, t.pendingWriteOffset = 0, t.pendingSamples = 0;
+    return;
+  }
+  const e = t.frameSize, r = t.frameBuffer, n = t.pendingBuffer.length;
+  for (; t.pendingSamples >= e; ) {
+    const i = t.pendingReadOffset;
+    if (i + e <= n)
+      r.set(t.pendingBuffer.subarray(i, i + e));
+    else {
+      const a = n - i;
+      r.set(t.pendingBuffer.subarray(i, n)), r.set(t.pendingBuffer.subarray(0, e - a), a);
+    }
+    t.pendingReadOffset = (i + e) % n, t.pendingSamples -= e;
+    const s = je(r);
+    t.lastVolume = s;
+    try {
+      if (t.useWasmEncoder)
+        t.encoder.encode(r);
+      else {
+        const a = new AudioData({
+          format: "f32",
+          sampleRate: t.sampleRate,
+          numberOfFrames: e,
+          numberOfChannels: t.channels,
+          timestamp: t.timestampUs,
+          data: r.buffer
+        });
+        t.encoder.encode(a), a.close();
+      }
+    } catch (a) {
+      w(a, t.captureId);
+    }
+    t.timestampUs += t.frameDurationUs;
+  }
+}
+function T(t, e) {
+  if (t.stopped)
+    return;
+  const r = e.length;
+  if (r === 0)
+    return;
+  const n = t.pendingSamples + r;
+  if (n > t.pendingBuffer.length) {
+    const a = Math.max(n, t.pendingBuffer.length * 2), c = new Float32Array(a);
+    if (t.pendingSamples > 0) {
+      const d = t.pendingBuffer.length;
+      if (t.pendingReadOffset + t.pendingSamples <= d)
+        c.set(t.pendingBuffer.subarray(t.pendingReadOffset, t.pendingReadOffset + t.pendingSamples));
+      else {
+        const o = d - t.pendingReadOffset;
+        c.set(t.pendingBuffer.subarray(t.pendingReadOffset, d)), c.set(t.pendingBuffer.subarray(0, t.pendingSamples - o), o);
+      }
+    }
+    t.pendingBuffer = c, t.pendingReadOffset = 0, t.pendingWriteOffset = t.pendingSamples;
+  }
+  const i = t.pendingBuffer.length, s = Math.min(r, i - t.pendingWriteOffset);
+  t.pendingBuffer.set(e.subarray(0, s), t.pendingWriteOffset), s < r && t.pendingBuffer.set(e.subarray(s), 0), t.pendingWriteOffset = (t.pendingWriteOffset + r) % i, t.pendingSamples += r, v(t);
+}
+function D(t, e, r, n, i = !0) {
+  const s = p.get(t.captureId);
+  if (!s || s.stopped || !s.inSegment && !s.segmentEndPending)
+    return;
+  const a = e.byteLength;
+  s.encoderOutputBuffer.length < a && (s.encoderOutputBuffer = new Uint8Array(Math.max(a, s.encoderOutputBuffer.length * 2))), s.encoderOutputBuffer.set(e);
+  const c = s.encoderOutputBuffer.subarray(0, a), d = s.segmentStartPending;
+  d && (s.segmentStartPending = !1, s.epoch++, s.sequence = 0);
+  const o = s.segmentEndPending;
+  o && (s.segmentEndPending = !1, s.inSegment = !1);
+  const h = s.frameSize * s.channels, y = BigInt(Math.floor(r / 1e6 * s.sampleRate * s.channels));
+  C(
+    he(
+      ce({
+        Samples: c,
+        Epoch: s.epoch,
+        Sequence: s.sequence,
+        FrameSizeInInterleavedSamples: h,
+        TimeStampInInterleavedSamples: y,
+        IsFirst: d,
+        IsLast: o,
+        AverageVolume: s.lastVolume,
+        AudioEventEstimatedDuration: 0
+      }),
+      s.senderId,
+      { trackId: s.trackId, targetIds: s.targetIds }
+    )
+  ), s.sequence++;
+}
+function Ze(t) {
+  const e = Math.max(M, Math.floor(t.options?.bitrate ?? b)), r = new AudioEncoder({
+    output: (n) => {
+      const i = p.get(t.captureId);
+      if (!i)
+        return;
+      const s = n.byteLength;
+      i.encoderOutputBuffer.length < s && (i.encoderOutputBuffer = new Uint8Array(Math.max(s, i.encoderOutputBuffer.length * 2))), n.copyTo(i.encoderOutputBuffer), D(
+        i,
+        i.encoderOutputBuffer.subarray(0, s),
+        n.timestamp ?? i.timestampUs,
+        n.duration ?? i.frameDurationUs,
+        n.type === "key"
+      );
+    },
+    error: (n) => {
+      w(n, t.captureId);
+    }
+  });
+  return r.configure({
+    codec: "opus",
+    numberOfChannels: t.channels,
+    sampleRate: t.sampleRate,
+    bitrate: e,
+    bitrateMode: "constant",
+    opus: {
+      application: "lowdelay",
+      signal: "voice"
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }), r;
+}
+function Qe(t) {
+  const e = Math.max(M, Math.floor(t.options?.bitrate ?? b));
+  return new $({
+    sampleRate: t.sampleRate,
+    channels: t.channels,
+    bitrate: e,
+    frameSize: t.frameSize,
+    onOutput: (r, n, i) => {
+      const s = p.get(t.captureId);
+      s && D(s, r, n, i, !0);
+    },
+    onError: (r) => {
+      w(r, t.captureId);
+    }
+  });
+}
+async function et() {
+  if (typeof AudioEncoder > "u")
+    return !1;
+  try {
+    return (await AudioEncoder.isConfigSupported({
+      codec: "opus",
+      numberOfChannels: 1,
+      sampleRate: 48e3
+    })).supported === !0;
+  } catch {
+    return !1;
+  }
+}
+async function tt(t) {
+  if (!I)
+    throw new Error("Audio capture worker missing send port");
+  if (p.has(t.captureId)) {
+    const f = p.get(t.captureId);
+    O({ type: "started", captureId: t.captureId, sampleRate: f.sampleRate, channels: f.channels });
+    return;
+  }
+  const e = Math.max(8e3, Math.floor(t.sampleRate)), r = Math.max(1, Math.floor(t.channels)), n = Math.max(1, Math.floor(e * He / 1e3)), i = Math.max(1, Math.floor(n * 1e6 / e)), s = n * 4, a = {
+    captureId: t.captureId,
+    streamId: t.streamId,
+    sourceType: t.sourceType,
+    senderId: t.senderId,
+    trackId: t.trackId,
+    sampleRate: e,
+    channels: r,
+    frameSize: n,
+    frameDurationUs: i,
+    timestampUs: 0,
+    sentFirst: !1,
+    stopped: !1,
+    transport: t.transport,
+    ringBuffer: null,
+    ringTemp: null,
+    pendingBuffer: new Float32Array(s),
+    pendingReadOffset: 0,
+    pendingWriteOffset: 0,
+    pendingSamples: 0,
+    frameBuffer: new Float32Array(n),
+    encoderOutputBuffer: new Uint8Array(1024),
+    inSegment: !1,
+    segmentStartPending: !1,
+    segmentEndPending: !1,
+    epoch: 0,
+    sequence: 0,
+    lastVolume: 0,
+    targetIds: t.options?.targetIds,
+    options: t.options,
+    correlationId: t.correlationId
+  }, d = (t.options?.preferWebCodecs ?? !0) && await et();
+  let o, h = !1;
+  const y = Math.max(M, Math.floor(t.options?.bitrate ?? b));
+  if (d)
+    o = Ze(a), g.debug(
+      `Audio capture started: encoder=WebCodecs, sampleRate=${e}Hz, channels=${r}, bitrate=${y}bps`
+    );
+  else {
+    const f = Qe(a);
+    await f.initialize(), o = f, h = !0, g.debug(
+      `Audio capture started: encoder=WASM Opus, sampleRate=${e}Hz, channels=${r}, bitrate=${y}bps`
+    );
+  }
+  const u = {
+    ...a,
+    encoder: o,
+    useWasmEncoder: h,
+    isReconfiguring: !1
+  };
+  if (t.transport === "sab") {
+    if (!t.sharedArrayBuffer)
+      throw new Error("Missing SharedArrayBuffer for sab transport");
+    const f = new Ce(t.sharedArrayBuffer, Float32Array);
+    u.ringBuffer = f, u.ringTemp = new Float32Array(Math.max(u.frameSize * 4, 4096)), Je(u);
+  }
+  p.set(t.captureId, u), C(
+    Be(
+      be({
+        StreamId: u.streamId,
+        Description: `mic:${u.streamId}`,
+        SourceType: u.sourceType,
+        Codec: P.Opus,
+        CodecDetails: "",
+        SampleRate: u.sampleRate,
+        Channels: u.channels,
+        CorrelationId: u.correlationId
+      }),
+      u.senderId,
+      { trackId: u.trackId, targetIds: u.targetIds }
+    )
+  ), O({ type: "started", captureId: t.captureId, sampleRate: e, channels: r });
+}
+async function j(t) {
+  const e = p.get(t);
+  if (e) {
+    e.stopped = !0, p.delete(t);
+    try {
+      v(e);
+    } catch {
+    }
+    try {
+      await e.encoder.flush();
+    } catch {
+    }
+    try {
+      e.encoder.close();
+    } catch {
+    }
+    C(Pe(Le({}), e.senderId, { trackId: e.trackId, targetIds: e.targetIds })), O({ type: "stopped", captureId: e.captureId }), Xe(t);
+  }
+}
+function rt(t) {
+  const e = p.get(t);
+  !e || e.stopped || (e.inSegment = !0, e.segmentStartPending = !0);
+}
+function nt(t) {
+  const e = p.get(t);
+  if (!(!e || e.stopped || !e.inSegment) && (e.segmentEndPending = !0, v(e), e.segmentEndPending && !e.stopped)) {
+    const r = e.frameSize - e.pendingSamples;
+    if (r > 0) {
+      const n = new Float32Array(r);
+      T(e, n);
+    }
+  }
+}
+async function it(t, e) {
+  const r = p.get(t);
+  if (!r || r.stopped)
+    return;
+  const n = r.options?.bitrate ?? b, i = e.bitrate ?? b;
+  if (n === i) {
+    r.options = e;
+    return;
+  }
+  r.isReconfiguring = !0, r.options = e;
+  const s = Math.max(M, Math.floor(i));
+  let a;
+  if (r.useWasmEncoder) {
+    const d = new $({
+      sampleRate: r.sampleRate,
+      channels: r.channels,
+      bitrate: s,
+      frameSize: r.frameSize,
+      onOutput: (o, h, y) => {
+        const u = p.get(r.captureId);
+        !u || u.isReconfiguring || D(u, o, h, y, !0);
+      },
+      onError: (o) => {
+        w(o, r.captureId);
+      }
+    });
+    try {
+      await d.initialize();
+    } catch (o) {
+      r.isReconfiguring = !1, w(o, t);
+      return;
+    }
+    a = d;
+  } else {
+    const d = new AudioEncoder({
+      output: (o) => {
+        const h = p.get(r.captureId);
+        if (!h || h.isReconfiguring)
+          return;
+        const y = o.byteLength;
+        h.encoderOutputBuffer.length < y && (h.encoderOutputBuffer = new Uint8Array(Math.max(y, h.encoderOutputBuffer.length * 2))), o.copyTo(h.encoderOutputBuffer), D(
+          h,
+          h.encoderOutputBuffer.subarray(0, y),
+          o.timestamp ?? h.timestampUs,
+          o.duration ?? h.frameDurationUs,
+          o.type === "key"
+        );
+      },
+      error: (o) => {
+        w(o, r.captureId);
+      }
+    });
+    d.configure({
+      codec: "opus",
+      numberOfChannels: r.channels,
+      sampleRate: r.sampleRate,
+      bitrate: s,
+      bitrateMode: "constant",
+      opus: {
+        application: "lowdelay",
+        signal: "voice"
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }), a = d;
+  }
+  const c = r.encoder;
+  try {
+    await c.flush();
+  } catch {
+  }
+  try {
+    c.close();
+  } catch {
+  }
+  r.encoder = a, r.isReconfiguring = !1, g.debug(`Audio capture bitrate updated: ${s}bps`);
+}
+async function st() {
+  const t = Array.from(p.keys()).map(
+    (e) => j(e).catch(() => {
+    })
+  );
+  if (await Promise.all(t), I) {
+    try {
+      I.close();
+    } catch {
+    }
+    I = null;
+  }
+}
+self.addEventListener("message", (t) => {
+  const e = t.data;
+  if (e.type === "attachSendPort") {
+    if (I)
+      try {
+        I.close();
+      } catch {
+      }
+    I = e.port;
+    try {
+      I.start?.();
+    } catch {
+    }
+    return;
+  }
+  if (e.type === "start") {
+    tt(e).catch((r) => {
+      w(r, e.captureId);
+    });
+    return;
+  }
+  if (e.type === "pcm") {
+    const r = p.get(e.captureId);
+    if (!r || r.stopped)
+      return;
+    T(r, e.pcm);
+    return;
+  }
+  if (e.type === "stop") {
+    j(e.captureId).catch((r) => {
+      g.warn(`Failed to stop audio capture: ${r}`), w(r, e.captureId);
+    });
+    return;
+  }
+  if (e.type === "startSegment") {
+    rt(e.captureId);
+    return;
+  }
+  if (e.type === "endSegment") {
+    nt(e.captureId);
+    return;
+  }
+  if (e.type === "updateOptions") {
+    it(e.captureId, e.options).catch((r) => {
+      g.warn(`Failed to update audio capture options: ${r}`), w(r, e.captureId);
+    });
+    return;
+  }
+  e.type === "dispose" && st().catch((r) => {
+    g.warn(`Failed to dispose audio capture worker: ${r}`);
+  });
+});