@ikonai/sdk 0.0.41 → 0.0.43

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

@@ -0,0 +1,1138 @@
+function B(t, e, r, n, i) {
+  const s = i?.trackId ?? 0, a = i?.sequenceId ?? 0, c = i?.flags ?? 0, l = i?.targetIds ?? [], d = i?.payloadType ?? 8, w = 27 + l.length * 4, I = w + e.length, y = new Uint8Array(I), u = new DataView(y.buffer);
+  u.setUint32(0, I, !0), u.setUint32(4, t >>> 0, !0), u.setUint32(8, n >>> 0, !0), u.setUint32(12, s >>> 0, !0), u.setUint32(16, a >>> 0, !0), u.setUint32(20, l.length >>> 0, !0), u.setUint8(24, r & 255), u.setUint8(25, d & 255), u.setUint8(26, c & 255);
+  let v = 27;
+  for (let U = 0; U < l.length; U++)
+    u.setUint32(v, l[U] >>> 0, !0), v += 4;
+  return y.set(e, w), y;
+}
+var f = /* @__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))(f || {});
+const K = 161, $ = 162, b = new TextEncoder();
+new TextDecoder("utf-8", { fatal: !0 });
+class E {
+  constructor(e = 1) {
+    this.version = e, this.buffer.writeByte(K), this.buffer.writeVarUInt(e >>> 0);
+  }
+  buffer = new m();
+  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 o ? 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 = b.encode(r ?? "");
+    this.writeVariableField(e, 12, n);
+  }
+  writeBinaryField(e, r) {
+    this.writeVariableField(e, 13, r);
+  }
+  writeObjectField(e, r, n) {
+    const i = new E(r);
+    n(i);
+    const s = i.finish();
+    this.writeVariableField(e, 11, s);
+  }
+  writeArrayField(e, r, n) {
+    const i = new _(r);
+    n(i);
+    const s = i.finish();
+    this.writeVariableField(e, 9, s);
+  }
+  writeDictionaryField(e, r, n, i) {
+    const s = new O(r, n);
+    i(s);
+    const a = s.finish();
+    this.writeVariableField(e, 10, a);
+  }
+  finish() {
+    return this.closed || (this.buffer.writeByte($), 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(F(r)), q(r) && this.buffer.writeVarUInt(n >>> 0);
+  }
+}
+class _ {
+  constructor(e) {
+    this.elementType = e;
+  }
+  payload = new m();
+  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 o ? 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 = b.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 E(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 _(e);
+    r(n);
+    const i = n.finish();
+    this.payload.writeBytes(i);
+  }
+  writeDictionary(e, r, n) {
+    this.ensureElementType(
+      10
+      /* Dict */
+    ), this.count++;
+    const i = new O(e, r);
+    n(i);
+    const s = i.finish();
+    this.payload.writeBytes(s);
+  }
+  finish() {
+    const e = new m();
+    return e.writeByte(F(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 ${f[this.elementType]}, expected ${f[e]}`);
+  }
+}
+class O {
+  constructor(e, r) {
+    this.keyType = e, this.valueType = r, G(e);
+  }
+  payload = new m();
+  count = 0;
+  entryOpen = !1;
+  beginEntry() {
+    if (this.entryOpen)
+      throw new Error("Previous dictionary entry not completed");
+    return this.count++, this.entryOpen = !0, new j(this.keyType, this.valueType, this.payload, () => {
+      this.entryOpen = !1;
+    });
+  }
+  finish() {
+    if (this.entryOpen)
+      throw new Error("Dictionary entry not completed");
+    const e = new m();
+    return e.writeByte(F(this.keyType)), e.writeByte(F(this.valueType)), e.writeVarUInt(this.count), e.writeBytes(this.payload.toUint8Array()), e.toUint8Array();
+  }
+}
+class j {
+  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 o ? 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 = b.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 o ? 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 = b.encode(e ?? "");
+    this.payload.writeVarUInt(r.length), this.payload.writeBytes(r), this.valueWritten = !0;
+  }
+  writeValueObject(e, r) {
+    this.ensureValueType(
+      11
+      /* Object */
+    );
+    const n = new E(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 _(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 O(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 ${f[this.keyType]}, expected ${f[e]}`);
+  }
+  ensureValueType(e) {
+    if (this.valueType !== e)
+      throw new Error(`Dictionary value type is ${f[this.valueType]}, expected ${f[e]}`);
+  }
+}
+class o {
+  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 = o.parseHexSlice(r, 0, 8), s = o.parseHexSlice(r, 8, 4), a = o.parseHexSlice(r, 12, 4);
+    o.writeUInt32LE(n, 0, i), o.writeUInt16LE(n, 4, s), o.writeUInt16LE(n, 6, a);
+    for (let c = 0; c < 8; c++)
+      n[8 + c] = o.parseHexSlice(r, 16 + c * 2, 2);
+    return new o(n);
+  }
+  static fromBytes(e) {
+    if (e.length !== 16)
+      throw new Error("Guid byte array must be 16 bytes");
+    return new o(Uint8Array.from(e));
+  }
+  static createZero() {
+    return new o(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 o(e);
+  }
+  toString() {
+    const e = this.bytes;
+    return [
+      o.toHex(o.readUInt32LE(e, 0), 8),
+      o.toHex(o.readUInt16LE(e, 4), 4),
+      o.toHex(o.readUInt16LE(e, 6), 4),
+      C(e.subarray(8, 10)),
+      C(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 m {
+  static INITIAL_CAPACITY = 256;
+  buffer;
+  dataView;
+  length = 0;
+  constructor() {
+    this.buffer = new Uint8Array(m.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 F(t, e = 0) {
+  if ((e & 240) !== 0)
+    throw new Error("Teleport flags must fit into 4 bits");
+  return (t & 15) << 4 | e & 15;
+}
+function q(t) {
+  return t === 12 || t === 13 || t === 9 || t === 11 || t === 10;
+}
+function G(t) {
+  if (t === 9 || t === 11 || t === 10 || t === 1)
+    throw new Error("Dictionary keys must be primitive Teleport types");
+}
+function C(t) {
+  return Array.from(t).map((e) => e.toString(16).padStart(2, "0")).join("");
+}
+var R = /* @__PURE__ */ ((t) => (t[t.Unknown = 0] = "Unknown", t[t.Opus = 1] = "Opus", t[t.Mp3 = 2] = "Mp3", t[t.RawPcm16 = 3] = "RawPcm16", t))(R || {});
+const N = 1, Y = 4194309, J = 205938238, Z = 717315017, Q = 1594075008, X = 2026534360, ee = 3409001585, te = 3466650495, re = 4007456593, ne = 4017217601, ie = 4065417427, se = 4086360332;
+function ae(t) {
+  const e = {};
+  return oe(e), t && Object.assign(e, t), e;
+}
+function oe(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.ShapeSetValues = void 0, t;
+}
+function ue(t) {
+  const e = new E(N);
+  return ce(t, e), e.finish();
+}
+function ce(t, e) {
+  e.writeFloat32Field(J, t.AverageVolume);
+  const r = t.ShapeSetValues;
+  r != null && e.writeArrayField(Z, f.Object, (n) => {
+    for (const i of r)
+      n.writeObject(he, (s) => {
+        pe(i, s);
+      });
+  }), e.writeBoolField(Q, t.IsFirst), e.writeUInt64Field(X, t.TimeStampInInterleavedSamples), e.writeBinaryField(ee, t.Samples), e.writeFloat32Field(te, t.AudioEventEstimatedDuration), e.writeUInt32Field(re, t.FrameSizeInInterleavedSamples >>> 0), e.writeBoolField(ne, t.IsLast), e.writeUInt32Field(ie, t.Sequence >>> 0), e.writeUInt32Field(se, t.Epoch >>> 0);
+}
+function le(t, e, r) {
+  const n = ue(t);
+  return B(Y, n, N, e, r);
+}
+const he = 1, de = 1154362099, fe = 3974819915;
+function pe(t, e) {
+  e.writeUInt32Field(de, t.SetId >>> 0), e.writeArrayField(fe, f.Float32, (r) => {
+    for (const n of t.Values)
+      r.writeFloat32(n);
+  });
+}
+const k = 1, ye = 4194305, we = 265814330, Ie = 1368629611, me = 2431514951, Ee = 2914494629, ge = 3284746250, Se = 4101844078;
+function Ae(t) {
+  const e = {};
+  return be(e), t && Object.assign(e, t), e;
+}
+function be(t) {
+  return t.Description = "", t.Codec = R.Unknown, t.SampleRate = 0, t.Channels = 0, t.BitDepth = 0, t.ShapeSets = void 0, t;
+}
+function Fe(t) {
+  const e = new E(k);
+  return _e(t, e), e.finish();
+}
+function _e(t, e) {
+  const r = t.ShapeSets;
+  r != null && e.writeArrayField(we, f.Object, (n) => {
+    for (const i of r)
+      n.writeObject(De, (s) => {
+        Me(i, s);
+      });
+  }), e.writeStringField(Ie, t.Description), e.writeInt32Field(me, t.Channels | 0), e.writeInt32Field(Ee, t.BitDepth | 0), e.writeInt32Field(ge, t.Codec), e.writeInt32Field(Se, t.SampleRate | 0);
+}
+function Ue(t, e, r) {
+  const n = Fe(t);
+  return B(ye, n, k, e, r);
+}
+const De = 1, Be = 1107713536, Oe = 1154362099, Re = 1185721362;
+function Me(t, e) {
+  e.writeStringField(Be, t.Name), e.writeUInt32Field(Oe, t.SetId >>> 0), e.writeArrayField(Re, f.String, (r) => {
+    for (const n of t.ShapeNames)
+      r.writeString(n);
+  });
+}
+const x = 1, Ve = 4194306;
+function Te(t) {
+  const e = {};
+  return t && Object.assign(e, t), e;
+}
+function Le(t) {
+  return new E(x).finish();
+}
+function Pe(t, e, r) {
+  const n = Le();
+  return B(Ve, n, x, e, r);
+}
+class We {
+  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;
+function Ce(t, e) {
+  return `[${t}] ${e}`;
+}
+function A(t, e, r, n) {
+  if ((/* @__PURE__ */ new Date()).toISOString(), ve <= t) {
+    const i = Ce(e, r);
+    switch (t) {
+      case 0:
+        console.debug(i, ...n);
+        break;
+      case 1:
+        console.info(i, ...n);
+        break;
+      case 2:
+        console.warn(i, ...n);
+        break;
+      case 3:
+        console.error(i, ...n);
+        break;
+    }
+  }
+}
+function Ne(t) {
+  return {
+    debug(e, ...r) {
+      A(0, t, e, r);
+    },
+    info(e, ...r) {
+      A(1, t, e, r);
+    },
+    warn(e, ...r) {
+      A(2, t, e, r);
+    },
+    error(e, ...r) {
+      A(3, t, e, r);
+    }
+  };
+}
+const ke = 20, M = 32e3, xe = 5, V = 8e3, D = Ne("AudioCaptureWorker");
+class He {
+  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-D2GAzJKe.js");
+      await n(), this.encoder = new e({
+        sampleRate: this.sampleRate,
+        channels: this.channels,
+        bitrate: this.bitrate,
+        application: r,
+        complexity: xe
+      }), 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 T = (t) => self.postMessage(t);
+let p = null;
+function g(t, e) {
+  const r = t instanceof Error ? t : new Error(String(t));
+  T({ type: "error", captureId: e, error: { name: r.name, message: r.message, stack: r.stack } });
+}
+function ze(t) {
+  return t.byteOffset === 0 && t.byteLength === t.buffer.byteLength ? t.buffer : t.slice().buffer;
+}
+function L(t) {
+  if (!p)
+    return;
+  const e = ze(t);
+  p.postMessage({ type: "send", message: e }, [e]);
+}
+function Ke(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 h = /* @__PURE__ */ new Map();
+let S = null;
+function $e() {
+  S === null && (S = self.setInterval(() => {
+    for (const t of h.values())
+      if (!(t.transport !== "sab" || !t.ringBuffer || !t.ringTemp || t.stopped))
+        try {
+          const e = t.ringBuffer.pop(t.ringTemp);
+          if (e <= 0)
+            continue;
+          W(t, t.ringTemp.subarray(0, e));
+        } catch (e) {
+          g(e, t.captureId);
+        }
+  }, 10));
+}
+function je() {
+  if (S === null)
+    return;
+  let t = !1;
+  for (const e of h.values())
+    if (e.transport === "sab" && !e.stopped) {
+      t = !0;
+      break;
+    }
+  if (!t) {
+    try {
+      self.clearInterval(S);
+    } catch {
+    }
+    S = null;
+  }
+}
+function P(t) {
+  if (t.stopped)
+    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 = Ke(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) {
+      g(a, t.captureId);
+    }
+    t.timestampUs += t.frameDurationUs;
+  }
+}
+function W(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 l = t.pendingBuffer.length;
+      if (t.pendingReadOffset + t.pendingSamples <= l)
+        c.set(t.pendingBuffer.subarray(t.pendingReadOffset, t.pendingReadOffset + t.pendingSamples));
+      else {
+        const d = l - t.pendingReadOffset;
+        c.set(t.pendingBuffer.subarray(t.pendingReadOffset, l)), c.set(t.pendingBuffer.subarray(0, t.pendingSamples - d), d);
+      }
+    }
+    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, P(t);
+}
+function H(t, e, r, n, i = !0) {
+  const s = h.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), l = s.segmentStartPending;
+  l && (s.segmentStartPending = !1, s.epoch++, s.sequence = 0);
+  const d = s.segmentEndPending;
+  d && (s.segmentEndPending = !1, s.inSegment = !1);
+  const w = s.frameSize * s.channels, I = BigInt(Math.floor(r / 1e6 * s.sampleRate * s.channels));
+  L(
+    le(
+      ae({
+        Samples: c,
+        Epoch: s.epoch,
+        Sequence: s.sequence,
+        FrameSizeInInterleavedSamples: w,
+        TimeStampInInterleavedSamples: I,
+        IsFirst: l,
+        IsLast: d,
+        AverageVolume: s.lastVolume,
+        AudioEventEstimatedDuration: 0
+      }),
+      s.senderId,
+      { trackId: s.trackId }
+    )
+  ), s.sequence++;
+}
+function qe(t) {
+  const e = Math.max(V, Math.floor(t.options?.bitrate ?? M)), r = new AudioEncoder({
+    output: (n) => {
+      const i = h.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), H(
+        i,
+        i.encoderOutputBuffer.subarray(0, s),
+        n.timestamp ?? i.timestampUs,
+        n.duration ?? i.frameDurationUs,
+        n.type === "key"
+      );
+    },
+    error: (n) => {
+      g(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 Ge(t) {
+  const e = Math.max(V, Math.floor(t.options?.bitrate ?? M));
+  return new He({
+    sampleRate: t.sampleRate,
+    channels: t.channels,
+    bitrate: e,
+    frameSize: t.frameSize,
+    onOutput: (r, n, i) => {
+      const s = h.get(t.captureId);
+      s && H(s, r, n, i, !0);
+    },
+    onError: (r) => {
+      g(r, t.captureId);
+    }
+  });
+}
+async function Ye() {
+  if (typeof AudioEncoder > "u")
+    return !1;
+  try {
+    return (await AudioEncoder.isConfigSupported({
+      codec: "opus",
+      numberOfChannels: 1,
+      sampleRate: 48e3
+    })).supported === !0;
+  } catch {
+    return !1;
+  }
+}
+async function Je(t) {
+  if (!p)
+    throw new Error("Audio capture worker missing send port");
+  if (h.has(t.captureId))
+    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 * ke / 1e3)), i = Math.max(1, Math.floor(n * 1e6 / e)), s = n * 4, a = {
+    captureId: t.captureId,
+    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,
+    options: t.options
+  }, l = (t.options?.preferWebCodecs ?? !0) && await Ye();
+  let d, w = !1;
+  const I = Math.max(V, Math.floor(t.options?.bitrate ?? M));
+  if (l)
+    d = qe(a), D.info(
+      `Audio capture started: encoder=WebCodecs, sampleRate=${e}Hz, channels=${r}, bitrate=${I}bps`
+    );
+  else {
+    const u = Ge(a);
+    await u.initialize(), d = u, w = !0, D.info(
+      `Audio capture started: encoder=WASM Opus, sampleRate=${e}Hz, channels=${r}, bitrate=${I}bps`
+    );
+  }
+  const y = {
+    ...a,
+    encoder: d,
+    useWasmEncoder: w
+  };
+  if (t.transport === "sab") {
+    if (!t.sharedArrayBuffer)
+      throw new Error("Missing SharedArrayBuffer for sab transport");
+    const u = new We(t.sharedArrayBuffer, Float32Array);
+    y.ringBuffer = u, y.ringTemp = new Float32Array(Math.max(y.frameSize * 4, 4096)), $e();
+  }
+  h.set(t.captureId, y), L(
+    Ue(
+      Ae({
+        Description: `mic:${t.captureId}`,
+        Codec: R.Opus,
+        SampleRate: e,
+        Channels: r,
+        BitDepth: 32
+      }),
+      t.senderId,
+      { trackId: t.trackId }
+    )
+  ), T({ type: "started", captureId: t.captureId, sampleRate: e, channels: r });
+}
+async function z(t) {
+  const e = h.get(t);
+  if (e) {
+    e.stopped = !0, h.delete(t);
+    try {
+      P(e);
+    } catch {
+    }
+    try {
+      await e.encoder.flush();
+    } catch {
+    }
+    try {
+      e.encoder.close();
+    } catch {
+    }
+    L(Pe(Te({}), e.senderId, { trackId: e.trackId })), T({ type: "stopped", captureId: t }), je();
+  }
+}
+function Ze(t) {
+  const e = h.get(t);
+  !e || e.stopped || (e.inSegment = !0, e.segmentStartPending = !0);
+}
+function Qe(t) {
+  const e = h.get(t);
+  if (!(!e || e.stopped || !e.inSegment) && (e.segmentEndPending = !0, P(e), e.segmentEndPending && !e.stopped)) {
+    const r = e.frameSize - e.pendingSamples;
+    if (r > 0) {
+      const n = new Float32Array(r);
+      W(e, n);
+    }
+  }
+}
+function Xe() {
+  for (const t of Array.from(h.keys()))
+    z(t);
+  if (p) {
+    try {
+      p.close();
+    } catch {
+    }
+    p = null;
+  }
+}
+self.addEventListener("message", (t) => {
+  const e = t.data;
+  if (e.type === "attachSendPort") {
+    if (p)
+      try {
+        p.close();
+      } catch {
+      }
+    p = e.port;
+    try {
+      p.start?.();
+    } catch {
+    }
+    return;
+  }
+  if (e.type === "start") {
+    Je(e).catch((r) => {
+      g(r, e.captureId);
+    });
+    return;
+  }
+  if (e.type === "pcm") {
+    const r = h.get(e.captureId);
+    if (!r || r.stopped)
+      return;
+    W(r, e.pcm);
+    return;
+  }
+  if (e.type === "stop") {
+    z(e.captureId).catch((r) => {
+      D.warn(`Failed to stop audio capture: ${r}`), g(r, e.captureId);
+    });
+    return;
+  }
+  if (e.type === "startSegment") {
+    Ze(e.captureId);
+    return;
+  }
+  if (e.type === "endSegment") {
+    Qe(e.captureId);
+    return;
+  }
+  e.type === "dispose" && Xe();
+});