@vonage/media-processor 2.0.0 → 2.0.2

package/dist/media-processor.static.js

@@ -0,0 +1,838 @@
+var V = Object.defineProperty;
+var Y = (t, e, r) => e in t ? V(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var a = (t, e, r) => (Y(t, typeof e != "symbol" ? e + "" : e, r), r);
+function ve() {
+  return new Promise((t, e) => {
+    typeof MediaStreamTrackProcessor > "u" || typeof MediaStreamTrackGenerator > "u" ? e("Your browser does not support the MediaStreamTrack API for Insertable Streams of Media.") : t();
+  });
+}
+class l {
+}
+a(l, "updates", {
+  transformer_new: "New transformer",
+  transformer_null: "Null transformer"
+}), a(l, "errors", {
+  transformer_none: "No transformers provided",
+  transformer_start: "Cannot start transformer",
+  transformer_transform: "Cannot transform frame",
+  transformer_flush: "Cannot flush transformer",
+  readable_null: "Readable is null",
+  writable_null: "Writable is null"
+});
+const h = /* @__PURE__ */ new WeakMap(), E = /* @__PURE__ */ new WeakMap(), y = /* @__PURE__ */ new WeakMap(), O = Symbol("anyProducer"), U = Promise.resolve(), k = Symbol("listenerAdded"), P = Symbol("listenerRemoved");
+let x = !1;
+function _(t) {
+  if (typeof t != "string" && typeof t != "symbol")
+    throw new TypeError("eventName must be a string or a symbol");
+}
+function T(t) {
+  if (typeof t != "function")
+    throw new TypeError("listener must be a function");
+}
+function g(t, e) {
+  const r = E.get(t);
+  return r.has(e) || r.set(e, /* @__PURE__ */ new Set()), r.get(e);
+}
+function b(t, e) {
+  const r = typeof e == "string" || typeof e == "symbol" ? e : O, s = y.get(t);
+  return s.has(r) || s.set(r, /* @__PURE__ */ new Set()), s.get(r);
+}
+function q(t, e, r) {
+  const s = y.get(t);
+  if (s.has(e))
+    for (const o of s.get(e))
+      o.enqueue(r);
+  if (s.has(O)) {
+    const o = Promise.all([e, r]);
+    for (const i of s.get(O))
+      i.enqueue(o);
+  }
+}
+function $(t, e) {
+  e = Array.isArray(e) ? e : [e];
+  let r = !1, s = () => {
+  }, o = [];
+  const i = {
+    enqueue(n) {
+      o.push(n), s();
+    },
+    finish() {
+      r = !0, s();
+    }
+  };
+  for (const n of e)
+    b(t, n).add(i);
+  return {
+    async next() {
+      return o ? o.length === 0 ? r ? (o = void 0, this.next()) : (await new Promise((n) => {
+        s = n;
+      }), this.next()) : {
+        done: !1,
+        value: await o.shift()
+      } : { done: !0 };
+    },
+    async return(n) {
+      o = void 0;
+      for (const c of e)
+        b(t, c).delete(i);
+      return s(), arguments.length > 0 ? { done: !0, value: await n } : { done: !0 };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function H(t) {
+  if (t === void 0)
+    return Q;
+  if (!Array.isArray(t))
+    throw new TypeError("`methodNames` must be an array of strings");
+  for (const e of t)
+    if (!Q.includes(e))
+      throw typeof e != "string" ? new TypeError("`methodNames` element must be a string") : new Error(`${e} is not Emittery method`);
+  return t;
+}
+const I = (t) => t === k || t === P;
+class m {
+  static mixin(e, r) {
+    return r = H(r), (s) => {
+      if (typeof s != "function")
+        throw new TypeError("`target` must be function");
+      for (const n of r)
+        if (s.prototype[n] !== void 0)
+          throw new Error(`The property \`${n}\` already exists on \`target\``);
+      function o() {
+        return Object.defineProperty(this, e, {
+          enumerable: !1,
+          value: new m()
+        }), this[e];
+      }
+      Object.defineProperty(s.prototype, e, {
+        enumerable: !1,
+        get: o
+      });
+      const i = (n) => function(...c) {
+        return this[e][n](...c);
+      };
+      for (const n of r)
+        Object.defineProperty(s.prototype, n, {
+          enumerable: !1,
+          value: i(n)
+        });
+      return s;
+    };
+  }
+  static get isDebugEnabled() {
+    if (typeof process != "object")
+      return x;
+    const { env: e } = process || { env: {} };
+    return e.DEBUG === "emittery" || e.DEBUG === "*" || x;
+  }
+  static set isDebugEnabled(e) {
+    x = e;
+  }
+  constructor(e = {}) {
+    h.set(this, /* @__PURE__ */ new Set()), E.set(this, /* @__PURE__ */ new Map()), y.set(this, /* @__PURE__ */ new Map()), this.debug = e.debug || {}, this.debug.enabled === void 0 && (this.debug.enabled = !1), this.debug.logger || (this.debug.logger = (r, s, o, i) => {
+      try {
+        i = JSON.stringify(i);
+      } catch {
+        i = `Object with the following keys failed to stringify: ${Object.keys(i).join(",")}`;
+      }
+      typeof o == "symbol" && (o = o.toString());
+      const n = new Date(), c = `${n.getHours()}:${n.getMinutes()}:${n.getSeconds()}.${n.getMilliseconds()}`;
+      console.log(`[${c}][emittery:${r}][${s}] Event Name: ${o}
+	data: ${i}`);
+    });
+  }
+  logIfDebugEnabled(e, r, s) {
+    (m.isDebugEnabled || this.debug.enabled) && this.debug.logger(e, this.debug.name, r, s);
+  }
+  on(e, r) {
+    T(r), e = Array.isArray(e) ? e : [e];
+    for (const s of e)
+      _(s), g(this, s).add(r), this.logIfDebugEnabled("subscribe", s, void 0), I(s) || this.emit(k, { eventName: s, listener: r });
+    return this.off.bind(this, e, r);
+  }
+  off(e, r) {
+    T(r), e = Array.isArray(e) ? e : [e];
+    for (const s of e)
+      _(s), g(this, s).delete(r), this.logIfDebugEnabled("unsubscribe", s, void 0), I(s) || this.emit(P, { eventName: s, listener: r });
+  }
+  once(e) {
+    return new Promise((r) => {
+      const s = this.on(e, (o) => {
+        s(), r(o);
+      });
+    });
+  }
+  events(e) {
+    e = Array.isArray(e) ? e : [e];
+    for (const r of e)
+      _(r);
+    return $(this, e);
+  }
+  async emit(e, r) {
+    _(e), this.logIfDebugEnabled("emit", e, r), q(this, e, r);
+    const s = g(this, e), o = h.get(this), i = [...s], n = I(e) ? [] : [...o];
+    await U, await Promise.all([
+      ...i.map(async (c) => {
+        if (s.has(c))
+          return c(r);
+      }),
+      ...n.map(async (c) => {
+        if (o.has(c))
+          return c(e, r);
+      })
+    ]);
+  }
+  async emitSerial(e, r) {
+    _(e), this.logIfDebugEnabled("emitSerial", e, r);
+    const s = g(this, e), o = h.get(this), i = [...s], n = [...o];
+    await U;
+    for (const c of i)
+      s.has(c) && await c(r);
+    for (const c of n)
+      o.has(c) && await c(e, r);
+  }
+  onAny(e) {
+    return T(e), this.logIfDebugEnabled("subscribeAny", void 0, void 0), h.get(this).add(e), this.emit(k, { listener: e }), this.offAny.bind(this, e);
+  }
+  anyEvent() {
+    return $(this);
+  }
+  offAny(e) {
+    T(e), this.logIfDebugEnabled("unsubscribeAny", void 0, void 0), this.emit(P, { listener: e }), h.get(this).delete(e);
+  }
+  clearListeners(e) {
+    e = Array.isArray(e) ? e : [e];
+    for (const r of e)
+      if (this.logIfDebugEnabled("clear", r, void 0), typeof r == "string" || typeof r == "symbol") {
+        g(this, r).clear();
+        const s = b(this, r);
+        for (const o of s)
+          o.finish();
+        s.clear();
+      } else {
+        h.get(this).clear();
+        for (const s of E.get(this).values())
+          s.clear();
+        for (const s of y.get(this).values()) {
+          for (const o of s)
+            o.finish();
+          s.clear();
+        }
+      }
+  }
+  listenerCount(e) {
+    e = Array.isArray(e) ? e : [e];
+    let r = 0;
+    for (const s of e) {
+      if (typeof s == "string") {
+        r += h.get(this).size + g(this, s).size + b(this, s).size + b(this).size;
+        continue;
+      }
+      typeof s < "u" && _(s), r += h.get(this).size;
+      for (const o of E.get(this).values())
+        r += o.size;
+      for (const o of y.get(this).values())
+        r += o.size;
+    }
+    return r;
+  }
+  bindMethods(e, r) {
+    if (typeof e != "object" || e === null)
+      throw new TypeError("`target` must be an object");
+    r = H(r);
+    for (const s of r) {
+      if (e[s] !== void 0)
+        throw new Error(`The property \`${s}\` already exists on \`target\``);
+      Object.defineProperty(e, s, {
+        enumerable: !1,
+        value: this[s].bind(this)
+      });
+    }
+  }
+}
+const Q = Object.getOwnPropertyNames(m.prototype).filter((t) => t !== "constructor");
+Object.defineProperty(m, "listenerAdded", {
+  value: k,
+  writable: !1,
+  enumerable: !0,
+  configurable: !1
+});
+Object.defineProperty(m, "listenerRemoved", {
+  value: P,
+  writable: !1,
+  enumerable: !0,
+  configurable: !1
+});
+var L = m;
+function J(t) {
+  return typeof t == "object" && t !== null && "message" in t && typeof t.message == "string";
+}
+function X(t) {
+  if (J(t))
+    return t;
+  try {
+    return new Error(JSON.stringify(t));
+  } catch {
+    return new Error(String(t));
+  }
+}
+function v(t) {
+  return X(t).message;
+}
+var Z = Object.defineProperty, K = (t, e, r) => e in t ? Z(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, N = (t, e, r) => (K(t, typeof e != "symbol" ? e + "" : e, r), r), ee = /* @__PURE__ */ ((t) => (t.automation = "automation", t.test = "test", t.vbc = "vbc", t.video = "video", t.voice = "voice", t))(ee || {});
+const re = "hlg.tokbox.com/prod/logging/vcp_webrtc", te = "https://", se = 1e4;
+let S;
+const oe = new Uint8Array(16);
+function ie() {
+  if (!S && (S = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !S))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return S(oe);
+}
+const f = [];
+for (let t = 0; t < 256; ++t)
+  f.push((t + 256).toString(16).slice(1));
+function ne(t, e = 0) {
+  return (f[t[e + 0]] + f[t[e + 1]] + f[t[e + 2]] + f[t[e + 3]] + "-" + f[t[e + 4]] + f[t[e + 5]] + "-" + f[t[e + 6]] + f[t[e + 7]] + "-" + f[t[e + 8]] + f[t[e + 9]] + "-" + f[t[e + 10]] + f[t[e + 11]] + f[t[e + 12]] + f[t[e + 13]] + f[t[e + 14]] + f[t[e + 15]]).toLowerCase();
+}
+const ae = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), G = {
+  randomUUID: ae
+};
+function ce(t, e, r) {
+  if (G.randomUUID && !e && !t)
+    return G.randomUUID();
+  t = t || {};
+  const s = t.random || (t.rng || ie)();
+  if (s[6] = s[6] & 15 | 64, s[8] = s[8] & 63 | 128, e) {
+    r = r || 0;
+    for (let o = 0; o < 16; ++o)
+      e[r + o] = s[o];
+    return e;
+  }
+  return ne(s);
+}
+function W(t, e) {
+  return globalThis[t] || (globalThis[t] = e), globalThis[t];
+}
+const p = W(
+  "globals",
+  {}
+);
+var d = /* @__PURE__ */ ((t) => (t.INIT = "INIT", t.FORWARD = "FORWARD", t.TERMINATE = "TERMINATE", t.GLOBALS_SYNC = "GLOBALS_SYNC", t))(d || {});
+function z(t) {
+  return [ImageBitmap, ReadableStream, WritableStream].some((e) => t instanceof e);
+}
+let fe = 0;
+function le(t, e, r, s, o) {
+  const i = fe++;
+  return t.postMessage(
+    {
+      id: i,
+      type: e,
+      functionName: r,
+      args: s
+    },
+    s.filter((n) => z(n))
+  ), new Promise((n) => {
+    o == null || o.set(i, n);
+  });
+}
+function w(t, e) {
+  const { id: r, type: s } = t, o = Array.isArray(e) ? e : [e];
+  postMessage(
+    {
+      id: r,
+      type: s,
+      result: e
+    },
+    o.filter((i) => z(i))
+  );
+}
+const j = W("workerized", {});
+function B() {
+  return typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope;
+}
+async function ue() {
+  if (B())
+    w({ type: d.GLOBALS_SYNC }, p);
+  else {
+    const t = [];
+    for (const e in j) {
+      const { worker: r, resolvers: s } = j[e].workerContext;
+      r && t.push(
+        le(
+          r,
+          d.GLOBALS_SYNC,
+          "",
+          [p],
+          s
+        )
+      );
+    }
+    await Promise.all(t);
+  }
+}
+function A(t, e) {
+  if (Array.isArray(e))
+    e.splice(0, e.length);
+  else if (typeof e == "object")
+    for (const r in e)
+      delete e[r];
+  for (const r in t)
+    Array.isArray(t[r]) ? (e[r] = [], A(t[r], e[r])) : typeof t[r] == "object" ? (e[r] = {}, A(t[r], e[r])) : e[r] = t[r];
+}
+async function he(t, e) {
+  const { functionName: r, args: s } = t;
+  if (!e.instance)
+    throw "instance not initialized";
+  if (!r)
+    throw "missing function name to call";
+  if (!e.instance[r])
+    throw `undefined function [${r}] in class ${e.instance.constructor.workerId}`;
+  w(t, await e.instance[r](...s != null ? s : []));
+}
+const pe = W("registeredWorkers", {});
+function de(t, e) {
+  if (!t.args)
+    throw "Missing className while initializing worker";
+  const [r, s] = t.args, o = pe[r];
+  if (o)
+    e.instance = new o(t.args.slice(1));
+  else
+    throw `unknown worker class ${r}`;
+  A(s, p), w(t, typeof e.instance !== void 0);
+}
+async function me(t, e) {
+  const { args: r } = t;
+  if (!e.instance)
+    throw "instance not initialized";
+  let s;
+  e.instance.terminate && (s = await e.instance.terminate(...r != null ? r : [])), w(t, s);
+}
+function _e(t) {
+  if (!t.args)
+    throw "Missing globals while syncing";
+  A(t.args[0], p), w(t, {});
+}
+function ge() {
+  const t = {};
+  onmessage = async (e) => {
+    const r = e.data;
+    switch (r.type) {
+      case d.INIT:
+        de(r, t);
+        break;
+      case d.FORWARD:
+        he(r, t);
+        break;
+      case d.TERMINATE:
+        me(r, t);
+        break;
+      case d.GLOBALS_SYNC:
+        _e(r);
+        break;
+    }
+  };
+}
+B() && ge();
+function ye(t, e) {
+  return p[t] || (p[t] = e), [
+    () => p[t],
+    async (r) => {
+      p[t] = r, await ue();
+    }
+  ];
+}
+function be(t, e) {
+  return ye(t, e);
+}
+const [we, Te] = be("metadata");
+function Ce(t) {
+  Te(t);
+}
+function C() {
+  return we();
+}
+class D {
+  constructor(e) {
+    N(this, "uuid", ce()), this.config = e;
+  }
+  async send(e) {
+    var r, s, o;
+    const { appId: i, sourceType: n } = (r = C()) != null ? r : {};
+    if (!i || !n)
+      return "metadata missing";
+    const c = new AbortController(), u = setTimeout(() => c.abort(), se);
+    return await ((o = (s = this.config) == null ? void 0 : s.fetch) != null ? o : fetch)(this.getUrl(), {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(this.buildReport(e)),
+      signal: c.signal
+    }), clearTimeout(u), "success";
+  }
+  getUrl() {
+    var e;
+    let r = (e = C().proxyUrl) != null ? e : te;
+    return r += (r.at(-1) === "/" ? "" : "/") + re, r;
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json"
+    };
+  }
+  buildReport(e) {
+    const r = C();
+    return {
+      guid: this.uuid,
+      ...e,
+      applicationId: r.appId,
+      timestamp: Date.now(),
+      proxyUrl: r.proxyUrl,
+      source: r.sourceType
+    };
+  }
+}
+const R = "2.0.2";
+class Se {
+  constructor(e) {
+    a(this, "frameTransformedCount", 0);
+    a(this, "frameFromSourceCount", 0);
+    a(this, "startAt", 0);
+    a(this, "reporter");
+    this.config = e, this.reporter = new D(e);
+  }
+  async onFrameFromSource() {
+    this.frameFromSourceCount++;
+  }
+  get fps() {
+    const { startAt: e, frameFromSourceCount: r } = this, o = (Date.now() - e) / 1e3;
+    return r / o;
+  }
+  async onFrameTransformed(e = {}, r = !1) {
+    this.startAt === 0 && (this.startAt = Date.now()), this.frameTransformedCount++;
+    const { startAt: s, frameTransformedCount: o, frameFromSourceCount: i } = this, n = Date.now(), c = (n - s) / 1e3, u = o / c, M = i / c;
+    return r || this.frameTransformedCount >= this.config.loggingIntervalFrameCount ? (this.frameFromSourceCount = 0, this.frameTransformedCount = 0, this.startAt = n, this.reporter.config = this.config, this.reporter.send({
+      ...this.config.report,
+      variation: "QoS",
+      fps: M,
+      transformedFps: u,
+      framesTransformed: o,
+      ...e
+    })) : "success";
+  }
+}
+var Ee = /* @__PURE__ */ ((t) => (t.FPS_DROP = "fps_drop", t))(Ee || {}), Re = /* @__PURE__ */ ((t) => (t.start = "start", t.transform = "transform", t.flush = "flush", t))(Re || {}), F = /* @__PURE__ */ ((t) => (t.pipeline_ended = "pipeline_ended", t.pipeline_ended_with_error = "pipeline_ended_with_error", t.pipeline_started = "pipeline_started", t.pipeline_started_with_error = "pipeline_started_with_error", t.pipeline_restarted = "pipeline_restarted", t.pipeline_restarted_with_error = "pipeline_restarted_with_error", t))(F || {});
+const ke = 500, Pe = 0.8;
+class Ae extends L {
+  constructor(r, s) {
+    super();
+    a(this, "reporter_", new D());
+    a(this, "reporterQos_", new Se({
+      loggingIntervalFrameCount: ke,
+      report: {
+        version: R
+      }
+    }));
+    a(this, "transformerType_");
+    a(this, "transformer_");
+    a(this, "shouldStop_");
+    a(this, "isFlashed_");
+    a(this, "mediaTransformerQosReportStartTimestamp_");
+    a(this, "videoHeight_");
+    a(this, "videoWidth_");
+    a(this, "trackExpectedRate_");
+    a(this, "index_");
+    a(this, "controller_");
+    this.index_ = s, this.transformer_ = r, this.shouldStop_ = !1, this.isFlashed_ = !1, this.mediaTransformerQosReportStartTimestamp_ = 0, this.videoHeight_ = 0, this.videoWidth_ = 0, this.trackExpectedRate_ = -1, this.transformerType_ = "Custom", "getTransformerType" in r && (this.transformerType_ = r.getTransformerType()), this.report({
+      variation: "Create"
+    });
+  }
+  setTrackExpectedRate(r) {
+    this.trackExpectedRate_ = r;
+  }
+  async start(r) {
+    if (this.controller_ = r, this.transformer_ && typeof this.transformer_.start == "function")
+      try {
+        await this.transformer_.start(r);
+      } catch (s) {
+        this.report({
+          message: l.errors.transformer_start,
+          variation: "Error",
+          error: v(s)
+        });
+        const o = { eventMetaData: { transformerIndex: this.index_ }, error: s, function: "start" };
+        this.emit("error", o);
+      }
+  }
+  async transform(r, s) {
+    var o, i, n, c;
+    if (this.mediaTransformerQosReportStartTimestamp_ === 0 && (this.mediaTransformerQosReportStartTimestamp_ = Date.now()), r instanceof VideoFrame && (this.videoHeight_ = (o = r == null ? void 0 : r.displayHeight) != null ? o : 0, this.videoWidth_ = (i = r == null ? void 0 : r.displayWidth) != null ? i : 0), this.reporterQos_.onFrameFromSource(), this.transformer_)
+      if (this.shouldStop_)
+        console.warn("[Pipeline] flush from transform"), r.close(), this.flush(s), s.terminate();
+      else {
+        try {
+          await ((c = (n = this.transformer_).transform) == null ? void 0 : c.call(n, r, s)), this.reportQos();
+        } catch (u) {
+          this.report({
+            message: l.errors.transformer_transform,
+            variation: "Error",
+            error: v(u)
+          });
+          const M = { eventMetaData: { transformerIndex: this.index_ }, error: u, function: "transform" };
+          this.emit("error", M);
+        }
+        if (this.trackExpectedRate_ != -1 && this.trackExpectedRate_ * Pe > this.reporterQos_.fps) {
+          const u = {
+            eventMetaData: {
+              transformerIndex: this.index_
+            },
+            warningType: "fps_drop",
+            dropInfo: {
+              requested: this.trackExpectedRate_,
+              current: this.reporterQos_.fps
+            }
+          };
+          this.emit("warn", u);
+        }
+      }
+  }
+  async flush(r) {
+    if (this.transformer_ && typeof this.transformer_.flush == "function" && !this.isFlashed_) {
+      this.isFlashed_ = !0;
+      try {
+        await this.transformer_.flush(r);
+      } catch (s) {
+        this.report({
+          message: l.errors.transformer_flush,
+          variation: "Error",
+          error: v(s)
+        });
+        const o = { eventMetaData: { transformerIndex: this.index_ }, error: s, function: "flush" };
+        this.emit("error", o);
+      }
+    }
+    this.reportQos(!0), this.report({
+      variation: "Delete"
+    });
+  }
+  stop() {
+    console.log("[Pipeline] Stop stream."), this.controller_ && (this.flush(this.controller_), this.controller_.terminate()), this.shouldStop_ = !0;
+  }
+  report(r) {
+    this.reporter_.send({
+      version: R,
+      action: "MediaTransformer",
+      transformerType: this.transformerType_,
+      ...r
+    });
+  }
+  reportQos(r = !1) {
+    this.reporterQos_.config = {
+      ...this.reporterQos_.config
+    }, this.reporterQos_.onFrameTransformed({
+      version: R,
+      action: "MediaTransformer",
+      transformerType: this.transformerType_,
+      videoWidth: this.videoWidth_,
+      videoHeight: this.videoHeight_
+    }, r);
+  }
+}
+class Me extends L {
+  constructor(r) {
+    super();
+    a(this, "transformers_");
+    a(this, "trackExpectedRate_");
+    this.transformers_ = [], this.trackExpectedRate_ = -1;
+    for (let s = 0; s < r.length; s++) {
+      let o = new Ae(r[s], s);
+      o.on("error", (i) => {
+        this.emit("error", i);
+      }), o.on("warn", (i) => {
+        this.emit("warn", i);
+      }), this.transformers_.push(o);
+    }
+  }
+  setTrackExpectedRate(r) {
+    this.trackExpectedRate_ = r;
+    for (let s of this.transformers_)
+      s.setTrackExpectedRate(this.trackExpectedRate_);
+  }
+  async start(r, s) {
+    if (!this.transformers_ || this.transformers_.length === 0) {
+      console.log("[Pipeline] No transformers.");
+      return;
+    }
+    try {
+      let o = r;
+      for (let i of this.transformers_)
+        r = r.pipeThrough(new TransformStream(i));
+      r.pipeTo(s).then(async () => {
+        console.log("[Pipeline] Setup."), await s.abort(), await o.cancel(), this.emit("pipelineInfo", "pipeline_ended");
+      }).catch(async (i) => {
+        r.cancel().then(() => {
+          console.log("[Pipeline] Shutting down streams after abort.");
+        }).catch((n) => {
+          console.error("[Pipeline] Error from stream transform:", n);
+        }), await s.abort(i), await o.cancel(i), this.emit("pipelineInfo", "pipeline_ended_with_error");
+      });
+    } catch {
+      this.emit("pipelineInfo", "pipeline_started_with_error"), this.destroy();
+      return;
+    }
+    this.emit("pipelineInfo", "pipeline_started"), console.log("[Pipeline] Pipeline started.");
+  }
+  async destroy() {
+    console.log("[Pipeline] Destroying Pipeline.");
+    for (let r of this.transformers_)
+      r.stop();
+  }
+}
+class Oe extends L {
+  constructor() {
+    super();
+    a(this, "reporter_");
+    a(this, "pipeline_");
+    a(this, "transformers_");
+    a(this, "readable_");
+    a(this, "writable_");
+    a(this, "trackExpectedRate_");
+    this.reporter_ = new D(), this.trackExpectedRate_ = -1, this.report({
+      variation: "Create"
+    });
+  }
+  setTrackExpectedRate(r) {
+    this.trackExpectedRate_ = r, this.pipeline_ && this.pipeline_.setTrackExpectedRate(this.trackExpectedRate_);
+  }
+  transform(r, s) {
+    return this.readable_ = r, this.writable_ = s, this.transformInternal();
+  }
+  transformInternal() {
+    return new Promise(async (r, s) => {
+      if (!this.transformers_ || this.transformers_.length === 0) {
+        this.report({
+          message: l.errors.transformer_none,
+          variation: "Error"
+        }), s("[MediaProcessor] Need to set transformers.");
+        return;
+      }
+      if (!this.readable_) {
+        this.report({
+          variation: "Error",
+          message: l.errors.readable_null
+        }), s("[MediaProcessor] Readable is null.");
+        return;
+      }
+      if (!this.writable_) {
+        this.report({
+          variation: "Error",
+          message: l.errors.writable_null
+        }), s("[MediaProcessor] Writable is null.");
+        return;
+      }
+      let o = !1;
+      this.pipeline_ && (o = !0, this.pipeline_.clearListeners(), this.pipeline_.destroy()), this.pipeline_ = new Me(this.transformers_), this.pipeline_.on("warn", (i) => {
+        this.emit("warn", i);
+      }), this.pipeline_.on("error", (i) => {
+        this.emit("error", i);
+      }), this.pipeline_.on("pipelineInfo", (i) => {
+        o && (i === "pipeline_started" ? i = F.pipeline_restarted : i === "pipeline_started_with_error" && (i = F.pipeline_restarted_with_error)), this.emit("pipelineInfo", i);
+      }), this.trackExpectedRate_ != -1 && this.pipeline_.setTrackExpectedRate(this.trackExpectedRate_), this.pipeline_.start(this.readable_, this.writable_).then(() => {
+        r();
+      }).catch((i) => {
+        s(i);
+      });
+    });
+  }
+  setTransformers(r) {
+    return this.report({
+      variation: "Update",
+      message: l.updates.transformer_new
+    }), this.transformers_ = r, this.readable_ && this.writable_ ? this.transformInternal() : Promise.resolve();
+  }
+  destroy() {
+    return new Promise(async (r) => {
+      this.pipeline_ && this.pipeline_.destroy(), this.report({ variation: "Delete" }), r();
+    });
+  }
+  report(r) {
+    this.reporter_.send({
+      version: R,
+      action: "MediaProcessor",
+      ...r
+    });
+  }
+}
+class xe {
+  constructor() {
+    a(this, "processor_");
+    a(this, "generator_");
+    this.processor_ = null, this.generator_ = null;
+  }
+  init(e) {
+    return new Promise((r, s) => {
+      try {
+        this.processor_ = new MediaStreamTrackProcessor(e);
+      } catch (o) {
+        console.log(`[InsertableStreamHelper] MediaStreamTrackProcessor failed: ${o}`), s(o);
+      }
+      try {
+        e.kind === "audio" ? this.generator_ = new MediaStreamTrackGenerator({ kind: "audio" }) : e.kind === "video" ? this.generator_ = new MediaStreamTrackGenerator({ kind: "video" }) : s("kind not supported");
+      } catch (o) {
+        console.log(`[InsertableStreamHelper] MediaStreamTrackGenerator failed: ${o}`), s(o);
+      }
+      r();
+    });
+  }
+  getReadable() {
+    return this.processor_.readable;
+  }
+  getWriteable() {
+    return this.generator_.writable;
+  }
+  getProccesorTrack() {
+    return this.generator_;
+  }
+}
+class Fe {
+  constructor(e) {
+    a(this, "insertableStreamHelper_");
+    a(this, "mediaProcessor_");
+    this.insertableStreamHelper_ = new xe(), this.mediaProcessor_ = e;
+  }
+  setTrack(e) {
+    return new Promise((r, s) => {
+      this.insertableStreamHelper_.init(e).then(() => {
+        this.mediaProcessor_.transform(this.insertableStreamHelper_.getReadable(), this.insertableStreamHelper_.getWriteable()).then(() => {
+          r(this.insertableStreamHelper_.getProccesorTrack());
+        }).catch((o) => {
+          s(o);
+        });
+      }).catch((o) => {
+        s(o);
+      });
+    });
+  }
+  destroy() {
+    return new Promise((e, r) => {
+      this.mediaProcessor_ ? this.mediaProcessor_.destroy().then(() => {
+        e();
+      }).catch((s) => {
+        r(s);
+      }) : r("no processor");
+    });
+  }
+}
+export {
+  Re as ErrorFunction,
+  Oe as MediaProcessor,
+  Fe as MediaProcessorConnector,
+  F as PipelineInfoData,
+  ee as VonageSourceType,
+  Ee as WarningType,
+  C as getVonageMetadata,
+  ve as isSupported,
+  Ce as setVonageMetadata
+};