sm-click-library-ui 0.0.390 → 0.0.393

package/dist/web-wri-esxC.js

@@ -0,0 +1,732 @@
+import { r as le, C as ge, W as me } from "./index-pIuAt61H.js";
+const F = {
+  RECORDING: "RECORDING",
+  PAUSED: "PAUSED",
+  NONE: "NONE"
+};
+function we(n) {
+  n.CapacitorUtils.Synapse = new Proxy(
+    {},
+    {
+      get(i, a) {
+        return new Proxy({}, {
+          get(p, d) {
+            return (l, c, f) => {
+              const s = n.Capacitor.Plugins[a];
+              if (s === void 0) {
+                f(new Error(`Capacitor plugin ${a} not found`));
+                return;
+              }
+              if (typeof s[d] != "function") {
+                f(new Error(`Method ${d} not found in Capacitor plugin ${a}`));
+                return;
+              }
+              (async () => {
+                try {
+                  const v = await s[d](l);
+                  c(v);
+                } catch (v) {
+                  f(v);
+                }
+              })();
+            };
+          }
+        });
+      }
+    }
+  );
+}
+function Re(n) {
+  n.CapacitorUtils.Synapse = new Proxy(
+    {},
+    {
+      get(i, a) {
+        return n.cordova.plugins[a];
+      }
+    }
+  );
+}
+function ye(n = !1) {
+  typeof window > "u" || (window.CapacitorUtils = window.CapacitorUtils || {}, window.Capacitor !== void 0 && !n ? we(window) : window.cordova !== void 0 && Re(window));
+}
+var re;
+(function(n) {
+  n.Documents = "DOCUMENTS", n.Data = "DATA", n.Library = "LIBRARY", n.Cache = "CACHE", n.External = "EXTERNAL", n.ExternalStorage = "EXTERNAL_STORAGE", n.ExternalCache = "EXTERNAL_CACHE", n.LibraryNoCloud = "LIBRARY_NO_CLOUD", n.Temporary = "TEMPORARY";
+})(re || (re = {}));
+var te;
+(function(n) {
+  n.UTF8 = "utf8", n.ASCII = "ascii", n.UTF16 = "utf16";
+})(te || (te = {}));
+const k = le("Filesystem", {
+  web: () => import("./web-s6lFS2jx.js").then((n) => new n.FilesystemWeb())
+});
+ye();
+const Ee = le("BlobWriter");
+function _e(n) {
+  return window.btoa(
+    Array.from(new Uint8Array(n)).map(function(i) {
+      return String.fromCharCode(i);
+    }).join("")
+  );
+}
+function be({
+  path: n,
+  directory: i,
+  blob: a,
+  recursive: p
+}) {
+  return k.writeFile({
+    directory: i,
+    path: n,
+    recursive: p,
+    data: ""
+  }).then(function() {
+    return new Promise(function(d, l) {
+      function c(s) {
+        l(s.target.error);
+      }
+      const f = window.indexedDB.open("Disc");
+      f.onerror = c, f.onsuccess = function() {
+        const v = f.result.transaction("FileStorage", "readwrite");
+        v.onerror = c;
+        const g = v.objectStore("FileStorage"), m = `/${i}/${n.replace(/^\//, "")}`, _ = g.get(m);
+        _.onsuccess = function() {
+          _.result.size = a.size, _.result.content = a;
+          const P = g.put(_.result);
+          P.onsuccess = function() {
+            d(void 0);
+          };
+        };
+      };
+    });
+  });
+}
+function ne({
+  path: n,
+  directory: i,
+  blob: a,
+  recursive: p
+}) {
+  return k.writeFile({
+    directory: i,
+    path: n,
+    recursive: p,
+    data: ""
+  }).then(function d() {
+    if (a.size === 0)
+      return Promise.resolve();
+    const l = 3 * 128 * 1024, c = a.slice(0, l);
+    return a = a.slice(l), new Response(
+      c
+    ).arrayBuffer().then(function(s) {
+      return k.appendFile({
+        directory: i,
+        path: n,
+        data: _e(s)
+      });
+    }).then(
+      d
+    );
+  });
+}
+function Se(n) {
+  const {
+    path: i,
+    directory: a,
+    blob: p,
+    fast_mode: d = !1,
+    recursive: l,
+    on_fallback: c
+  } = n;
+  return !p || !Number.isSafeInteger(p.size) || typeof p.type != "string" ? Promise.reject(new Error("Not a Blob.")) : ge.getPlatform() === "web" ? d ? be(n) : ne(n) : Promise.all([
+    Ee.get_config(),
+    k.getUri({ path: i, directory: a })
+  ]).then(function([f, s]) {
+    const v = s.uri.replace("file://", "");
+    return (window.CapacitorWebFetch || window.fetch)(
+      f.base_url + v + (l ? "?recursive=true" : ""),
+      {
+        headers: { authorization: f.auth_token },
+        method: "put",
+        body: p
+      }
+    ).then(function(m) {
+      if (m.status !== 204)
+        throw new Error("Bad HTTP status: " + m.status);
+      return s.uri;
+    });
+  }).catch(function(s) {
+    return c !== void 0 && c(s), ne(n);
+  });
+}
+const Pe = Object.freeze(Se);
+function Oe(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var fe = {};
+function Te(n) {
+  return n && n.__esModule ? n : {
+    default: n
+  };
+}
+var Ne = Te, W = { exports: {} }, oe;
+function Ce() {
+  return oe || (oe = 1, function(n) {
+    var i = function(a) {
+      var p = Object.prototype, d = p.hasOwnProperty, l = Object.defineProperty || function(r, e, t) {
+        r[e] = t.value;
+      }, c, f = typeof Symbol == "function" ? Symbol : {}, s = f.iterator || "@@iterator", v = f.asyncIterator || "@@asyncIterator", g = f.toStringTag || "@@toStringTag";
+      function m(r, e, t) {
+        return Object.defineProperty(r, e, {
+          value: t,
+          enumerable: !0,
+          configurable: !0,
+          writable: !0
+        }), r[e];
+      }
+      try {
+        m({}, "");
+      } catch {
+        m = function(e, t, u) {
+          return e[t] = u;
+        };
+      }
+      function _(r, e, t, u) {
+        var o = e && e.prototype instanceof U ? e : U, h = Object.create(o.prototype), w = new $(u || []);
+        return l(h, "_invoke", { value: pe(r, t, w) }), h;
+      }
+      a.wrap = _;
+      function P(r, e, t) {
+        try {
+          return { type: "normal", arg: r.call(e, t) };
+        } catch (u) {
+          return { type: "throw", arg: u };
+        }
+      }
+      var x = "suspendedStart", he = "suspendedYield", J = "executing", A = "completed", b = {};
+      function U() {
+      }
+      function I() {
+      }
+      function T() {
+      }
+      var j = {};
+      m(j, s, function() {
+        return this;
+      });
+      var B = Object.getPrototypeOf, G = B && B(B(Y([])));
+      G && G !== p && d.call(G, s) && (j = G);
+      var C = T.prototype = U.prototype = Object.create(j);
+      I.prototype = T, l(C, "constructor", { value: T, configurable: !0 }), l(
+        T,
+        "constructor",
+        { value: I, configurable: !0 }
+      ), I.displayName = m(
+        T,
+        g,
+        "GeneratorFunction"
+      );
+      function K(r) {
+        ["next", "throw", "return"].forEach(function(e) {
+          m(r, e, function(t) {
+            return this._invoke(e, t);
+          });
+        });
+      }
+      a.isGeneratorFunction = function(r) {
+        var e = typeof r == "function" && r.constructor;
+        return e ? e === I || // For the native GeneratorFunction constructor, the best we can
+        // do is to check its .name property.
+        (e.displayName || e.name) === "GeneratorFunction" : !1;
+      }, a.mark = function(r) {
+        return Object.setPrototypeOf ? Object.setPrototypeOf(r, T) : (r.__proto__ = T, m(r, g, "GeneratorFunction")), r.prototype = Object.create(C), r;
+      }, a.awrap = function(r) {
+        return { __await: r };
+      };
+      function M(r, e) {
+        function t(h, w, R, E) {
+          var y = P(r[h], r, w);
+          if (y.type === "throw")
+            E(y.arg);
+          else {
+            var z = y.arg, D = z.value;
+            return D && typeof D == "object" && d.call(D, "__await") ? e.resolve(D.__await).then(function(N) {
+              t("next", N, R, E);
+            }, function(N) {
+              t("throw", N, R, E);
+            }) : e.resolve(D).then(function(N) {
+              z.value = N, R(z);
+            }, function(N) {
+              return t("throw", N, R, E);
+            });
+          }
+        }
+        var u;
+        function o(h, w) {
+          function R() {
+            return new e(function(E, y) {
+              t(h, w, E, y);
+            });
+          }
+          return u = // If enqueue has been called before, then we want to wait until
+          // all previous Promises have been resolved before calling invoke,
+          // so that results are always delivered in the correct order. If
+          // enqueue has not been called before, then it is important to
+          // call invoke immediately, without waiting on a callback to fire,
+          // so that the async generator function has the opportunity to do
+          // any necessary setup in a predictable way. This predictability
+          // is why the Promise constructor synchronously invokes its
+          // executor callback, and why async functions synchronously
+          // execute code before the first await. Since we implement simple
+          // async functions in terms of async generators, it is especially
+          // important to get this right, even though it requires care.
+          u ? u.then(
+            R,
+            // Avoid propagating failures to Promises returned by later
+            // invocations of the iterator.
+            R
+          ) : R();
+        }
+        l(this, "_invoke", { value: o });
+      }
+      K(M.prototype), m(M.prototype, v, function() {
+        return this;
+      }), a.AsyncIterator = M, a.async = function(r, e, t, u, o) {
+        o === void 0 && (o = Promise);
+        var h = new M(
+          _(r, e, t, u),
+          o
+        );
+        return a.isGeneratorFunction(e) ? h : h.next().then(function(w) {
+          return w.done ? w.value : h.next();
+        });
+      };
+      function pe(r, e, t) {
+        var u = x;
+        return function(h, w) {
+          if (u === J)
+            throw new Error("Generator is already running");
+          if (u === A) {
+            if (h === "throw")
+              throw w;
+            return ee();
+          }
+          for (t.method = h, t.arg = w; ; ) {
+            var R = t.delegate;
+            if (R) {
+              var E = Z(R, t);
+              if (E) {
+                if (E === b) continue;
+                return E;
+              }
+            }
+            if (t.method === "next")
+              t.sent = t._sent = t.arg;
+            else if (t.method === "throw") {
+              if (u === x)
+                throw u = A, t.arg;
+              t.dispatchException(t.arg);
+            } else t.method === "return" && t.abrupt("return", t.arg);
+            u = J;
+            var y = P(r, e, t);
+            if (y.type === "normal") {
+              if (u = t.done ? A : he, y.arg === b)
+                continue;
+              return {
+                value: y.arg,
+                done: t.done
+              };
+            } else y.type === "throw" && (u = A, t.method = "throw", t.arg = y.arg);
+          }
+        };
+      }
+      function Z(r, e) {
+        var t = e.method, u = r.iterator[t];
+        if (u === c)
+          return e.delegate = null, t === "throw" && r.iterator.return && (e.method = "return", e.arg = c, Z(r, e), e.method === "throw") || t !== "return" && (e.method = "throw", e.arg = new TypeError(
+            "The iterator does not provide a '" + t + "' method"
+          )), b;
+        var o = P(u, r.iterator, e.arg);
+        if (o.type === "throw")
+          return e.method = "throw", e.arg = o.arg, e.delegate = null, b;
+        var h = o.arg;
+        if (!h)
+          return e.method = "throw", e.arg = new TypeError("iterator result is not an object"), e.delegate = null, b;
+        if (h.done)
+          e[r.resultName] = h.value, e.next = r.nextLoc, e.method !== "return" && (e.method = "next", e.arg = c);
+        else
+          return h;
+        return e.delegate = null, b;
+      }
+      K(C), m(C, g, "Generator"), m(C, s, function() {
+        return this;
+      }), m(C, "toString", function() {
+        return "[object Generator]";
+      });
+      function ve(r) {
+        var e = { tryLoc: r[0] };
+        1 in r && (e.catchLoc = r[1]), 2 in r && (e.finallyLoc = r[2], e.afterLoc = r[3]), this.tryEntries.push(e);
+      }
+      function q(r) {
+        var e = r.completion || {};
+        e.type = "normal", delete e.arg, r.completion = e;
+      }
+      function $(r) {
+        this.tryEntries = [{ tryLoc: "root" }], r.forEach(ve, this), this.reset(!0);
+      }
+      a.keys = function(r) {
+        var e = Object(r), t = [];
+        for (var u in e)
+          t.push(u);
+        return t.reverse(), function o() {
+          for (; t.length; ) {
+            var h = t.pop();
+            if (h in e)
+              return o.value = h, o.done = !1, o;
+          }
+          return o.done = !0, o;
+        };
+      };
+      function Y(r) {
+        if (r) {
+          var e = r[s];
+          if (e)
+            return e.call(r);
+          if (typeof r.next == "function")
+            return r;
+          if (!isNaN(r.length)) {
+            var t = -1, u = function o() {
+              for (; ++t < r.length; )
+                if (d.call(r, t))
+                  return o.value = r[t], o.done = !1, o;
+              return o.value = c, o.done = !0, o;
+            };
+            return u.next = u;
+          }
+        }
+        return { next: ee };
+      }
+      a.values = Y;
+      function ee() {
+        return { value: c, done: !0 };
+      }
+      return $.prototype = {
+        constructor: $,
+        reset: function(r) {
+          if (this.prev = 0, this.next = 0, this.sent = this._sent = c, this.done = !1, this.delegate = null, this.method = "next", this.arg = c, this.tryEntries.forEach(q), !r)
+            for (var e in this)
+              e.charAt(0) === "t" && d.call(this, e) && !isNaN(+e.slice(1)) && (this[e] = c);
+        },
+        stop: function() {
+          this.done = !0;
+          var r = this.tryEntries[0], e = r.completion;
+          if (e.type === "throw")
+            throw e.arg;
+          return this.rval;
+        },
+        dispatchException: function(r) {
+          if (this.done)
+            throw r;
+          var e = this;
+          function t(E, y) {
+            return h.type = "throw", h.arg = r, e.next = E, y && (e.method = "next", e.arg = c), !!y;
+          }
+          for (var u = this.tryEntries.length - 1; u >= 0; --u) {
+            var o = this.tryEntries[u], h = o.completion;
+            if (o.tryLoc === "root")
+              return t("end");
+            if (o.tryLoc <= this.prev) {
+              var w = d.call(o, "catchLoc"), R = d.call(o, "finallyLoc");
+              if (w && R) {
+                if (this.prev < o.catchLoc)
+                  return t(o.catchLoc, !0);
+                if (this.prev < o.finallyLoc)
+                  return t(o.finallyLoc);
+              } else if (w) {
+                if (this.prev < o.catchLoc)
+                  return t(o.catchLoc, !0);
+              } else if (R) {
+                if (this.prev < o.finallyLoc)
+                  return t(o.finallyLoc);
+              } else
+                throw new Error("try statement without catch or finally");
+            }
+          }
+        },
+        abrupt: function(r, e) {
+          for (var t = this.tryEntries.length - 1; t >= 0; --t) {
+            var u = this.tryEntries[t];
+            if (u.tryLoc <= this.prev && d.call(u, "finallyLoc") && this.prev < u.finallyLoc) {
+              var o = u;
+              break;
+            }
+          }
+          o && (r === "break" || r === "continue") && o.tryLoc <= e && e <= o.finallyLoc && (o = null);
+          var h = o ? o.completion : {};
+          return h.type = r, h.arg = e, o ? (this.method = "next", this.next = o.finallyLoc, b) : this.complete(h);
+        },
+        complete: function(r, e) {
+          if (r.type === "throw")
+            throw r.arg;
+          return r.type === "break" || r.type === "continue" ? this.next = r.arg : r.type === "return" ? (this.rval = this.arg = r.arg, this.method = "return", this.next = "end") : r.type === "normal" && e && (this.next = e), b;
+        },
+        finish: function(r) {
+          for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+            var t = this.tryEntries[e];
+            if (t.finallyLoc === r)
+              return this.complete(t.completion, t.afterLoc), q(t), b;
+          }
+        },
+        catch: function(r) {
+          for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+            var t = this.tryEntries[e];
+            if (t.tryLoc === r) {
+              var u = t.completion;
+              if (u.type === "throw") {
+                var o = u.arg;
+                q(t);
+              }
+              return o;
+            }
+          }
+          throw new Error("illegal catch attempt");
+        },
+        delegateYield: function(r, e, t) {
+          return this.delegate = {
+            iterator: Y(r),
+            resultName: e,
+            nextLoc: t
+          }, this.method === "next" && (this.arg = c), b;
+        }
+      }, a;
+    }(
+      // If this script is executing as a CommonJS module, use module.exports
+      // as the regeneratorRuntime namespace. Otherwise create a new empty
+      // object. Either way, the resulting object will be used to initialize
+      // the regeneratorRuntime variable at the top of this file.
+      n.exports
+    );
+    try {
+      regeneratorRuntime = i;
+    } catch {
+      typeof globalThis == "object" ? globalThis.regeneratorRuntime = i : Function("r", "regeneratorRuntime = r")(i);
+    }
+  }(W)), W.exports;
+}
+var H, ie;
+function De() {
+  return ie || (ie = 1, H = Ce()), H;
+}
+var V, ae;
+function Le() {
+  if (ae) return V;
+  ae = 1;
+  function n(a, p, d, l, c, f, s) {
+    try {
+      var v = a[f](s), g = v.value;
+    } catch (m) {
+      d(m);
+      return;
+    }
+    v.done ? p(g) : Promise.resolve(g).then(l, c);
+  }
+  function i(a) {
+    return function() {
+      var p = this, d = arguments;
+      return new Promise(function(l, c) {
+        var f = a.apply(p, d);
+        function s(g) {
+          n(f, l, c, s, v, "next", g);
+        }
+        function v(g) {
+          n(f, l, c, s, v, "throw", g);
+        }
+        s(void 0);
+      });
+    };
+  }
+  return V = i, V;
+}
+(function(n) {
+  var i = Ne;
+  Object.defineProperty(n, "__esModule", { value: !0 }), n.default = d;
+  var a = i(De()), p = i(Le());
+  function d(c) {
+    return l.apply(this, arguments);
+  }
+  function l() {
+    return (l = (0, p.default)(a.default.mark(function c(f) {
+      var s, v;
+      return a.default.wrap(function(g) {
+        for (; ; ) switch (g.prev = g.next) {
+          case 0:
+            return s = document.createElement("video"), v = new Promise(function(m, _) {
+              s.addEventListener("loadedmetadata", function() {
+                s.duration === 1 / 0 ? (s.currentTime = Number.MAX_SAFE_INTEGER, s.ontimeupdate = function() {
+                  s.ontimeupdate = null, m(s.duration), s.currentTime = 0;
+                }) : m(s.duration);
+              }), s.onerror = function(P) {
+                return _(P.target.error);
+              };
+            }), s.src = typeof f == "string" || f instanceof String ? f : window.URL.createObjectURL(f), g.abrupt("return", v);
+          case 4:
+          case "end":
+            return g.stop();
+        }
+      }, c);
+    }))).apply(this, arguments);
+  }
+})(fe);
+const Ae = /* @__PURE__ */ Oe(fe), O = () => ({ value: !0 }), L = () => ({ value: !1 }), Ie = () => new Error("MISSING_PERMISSION"), Ge = () => new Error("ALREADY_RECORDING"), Me = () => new Error("DEVICE_CANNOT_VOICE_RECORD"), se = () => new Error("FAILED_TO_RECORD"), Fe = () => new Error("EMPTY_RECORDING"), X = () => new Error("RECORDING_HAS_NOT_STARTED"), ue = () => new Error("FAILED_TO_FETCH_RECORDING"), Q = () => new Error("COULD_NOT_QUERY_PERMISSION_STATUS"), ce = {
+  "audio/aac": ".aac",
+  "audio/mp4": ".mp3",
+  "audio/webm;codecs=opus": ".ogg",
+  "audio/webm": ".ogg",
+  "audio/ogg;codecs=opus": ".ogg"
+}, de = () => new Promise(() => {
+});
+class S {
+  constructor() {
+    this.mediaRecorder = null, this.chunks = [], this.pendingResult = de();
+  }
+  static async canDeviceVoiceRecord() {
+    var i;
+    return ((i = navigator == null ? void 0 : navigator.mediaDevices) === null || i === void 0 ? void 0 : i.getUserMedia) == null || S.getSupportedMimeType() == null ? L() : O();
+  }
+  async startRecording(i) {
+    if (this.mediaRecorder != null)
+      throw Ge();
+    if (!(await S.canDeviceVoiceRecord()).value)
+      throw Me();
+    if (!(await S.hasAudioRecordingPermission().catch(() => O())).value)
+      throw Ie();
+    return navigator.mediaDevices.getUserMedia({ audio: !0 }).then((d) => this.onSuccessfullyStartedRecording(d, i)).catch(this.onFailedToStartRecording.bind(this));
+  }
+  async stopRecording() {
+    if (this.mediaRecorder == null)
+      throw X();
+    try {
+      return this.mediaRecorder.stop(), this.mediaRecorder.stream.getTracks().forEach((i) => i.stop()), this.pendingResult;
+    } catch {
+      throw ue();
+    } finally {
+      this.prepareInstanceForNextOperation();
+    }
+  }
+  static async hasAudioRecordingPermission() {
+    return navigator.permissions.query == null ? navigator.mediaDevices == null ? Promise.reject(Q()) : navigator.mediaDevices.getUserMedia({ audio: !0 }).then(() => O()).catch(() => {
+      throw Q();
+    }) : navigator.permissions.query({ name: "microphone" }).then((i) => ({ value: i.state === "granted" })).catch(() => {
+      throw Q();
+    });
+  }
+  static async requestAudioRecordingPermission() {
+    return (await S.hasAudioRecordingPermission().catch(() => L())).value ? O() : navigator.mediaDevices.getUserMedia({ audio: !0 }).then(() => O()).catch(() => L());
+  }
+  pauseRecording() {
+    if (this.mediaRecorder == null)
+      throw X();
+    return this.mediaRecorder.state === "recording" ? (this.mediaRecorder.pause(), Promise.resolve(O())) : Promise.resolve(L());
+  }
+  resumeRecording() {
+    if (this.mediaRecorder == null)
+      throw X();
+    return this.mediaRecorder.state === "paused" ? (this.mediaRecorder.resume(), Promise.resolve(O())) : Promise.resolve(L());
+  }
+  getCurrentStatus() {
+    return this.mediaRecorder == null ? Promise.resolve({ status: F.NONE }) : this.mediaRecorder.state === "recording" ? Promise.resolve({ status: F.RECORDING }) : this.mediaRecorder.state === "paused" ? Promise.resolve({ status: F.PAUSED }) : Promise.resolve({ status: F.NONE });
+  }
+  static getSupportedMimeType() {
+    if ((MediaRecorder == null ? void 0 : MediaRecorder.isTypeSupported) == null)
+      return null;
+    const i = Object.keys(ce).find((a) => MediaRecorder.isTypeSupported(a));
+    return i ?? null;
+  }
+  onSuccessfullyStartedRecording(i, a) {
+    return this.pendingResult = new Promise((p, d) => {
+      this.mediaRecorder = new MediaRecorder(i), this.mediaRecorder.onerror = () => {
+        this.prepareInstanceForNextOperation(), d(se());
+      }, this.mediaRecorder.onstop = async () => {
+        var l, c, f;
+        const s = S.getSupportedMimeType();
+        if (s == null) {
+          this.prepareInstanceForNextOperation(), d(ue());
+          return;
+        }
+        const v = new Blob(this.chunks, { type: s });
+        if (v.size <= 0) {
+          this.prepareInstanceForNextOperation(), d(Fe());
+          return;
+        }
+        let g, m;
+        a != null ? (g = `${(f = (c = (l = a.subDirectory) === null || l === void 0 ? void 0 : l.match(/^\/?(.+[^/])\/?$/)) === null || c === void 0 ? void 0 : c[1]) !== null && f !== void 0 ? f : ""}/recording-${(/* @__PURE__ */ new Date()).getTime()}${ce[s]}`, await Pe({
+          blob: v,
+          directory: a.directory,
+          fast_mode: !0,
+          path: g,
+          recursive: !0
+        })) : m = await S.blobToBase64(v);
+        const _ = await Ae(v);
+        this.prepareInstanceForNextOperation(), p({ value: { recordDataBase64: m, mimeType: s, msDuration: _ * 1e3, path: g } });
+      }, this.mediaRecorder.ondataavailable = (l) => this.chunks.push(l.data), this.mediaRecorder.start();
+    }), O();
+  }
+  onFailedToStartRecording() {
+    throw this.prepareInstanceForNextOperation(), se();
+  }
+  static blobToBase64(i) {
+    return new Promise((a) => {
+      const p = new FileReader();
+      p.onloadend = () => {
+        const d = String(p.result), l = d.split("base64,"), c = l.length > 1 ? l[1] : d;
+        a(c.trim());
+      }, p.readAsDataURL(i);
+    });
+  }
+  prepareInstanceForNextOperation() {
+    if (this.mediaRecorder != null && this.mediaRecorder.state === "recording")
+      try {
+        this.mediaRecorder.stop();
+      } catch (i) {
+        console.warn("While trying to stop a media recorder, an error was thrown", i);
+      }
+    this.pendingResult = de(), this.mediaRecorder = null, this.chunks = [];
+  }
+}
+class ke extends me {
+  constructor() {
+    super(...arguments), this.voiceRecorderInstance = new S();
+  }
+  canDeviceVoiceRecord() {
+    return S.canDeviceVoiceRecord();
+  }
+  hasAudioRecordingPermission() {
+    return S.hasAudioRecordingPermission();
+  }
+  requestAudioRecordingPermission() {
+    return S.requestAudioRecordingPermission();
+  }
+  startRecording(i) {
+    return this.voiceRecorderInstance.startRecording(i);
+  }
+  stopRecording() {
+    return this.voiceRecorderInstance.stopRecording();
+  }
+  pauseRecording() {
+    return this.voiceRecorderInstance.pauseRecording();
+  }
+  resumeRecording() {
+    return this.voiceRecorderInstance.resumeRecording();
+  }
+  getCurrentStatus() {
+    return this.voiceRecorderInstance.getCurrentStatus();
+  }
+}
+const je = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  VoiceRecorderWeb: ke
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  te as E,
+  je as w
+};