secure-redact 1.0.0

package/dist/assets/index-C62fEJ4q.js

@@ -0,0 +1,888 @@
+function He(i, o) {
+  return o.forEach(function(n) {
+    n && typeof n != "string" && !Array.isArray(n) && Object.keys(n).forEach(function(c) {
+      if (c !== "default" && !(c in i)) {
+        var s = Object.getOwnPropertyDescriptor(n, c);
+        Object.defineProperty(i, c, s.get ? s : {
+          enumerable: !0,
+          get: function() {
+            return n[c];
+          }
+        });
+      }
+    });
+  }), Object.freeze(i);
+}
+function Je(i) {
+  return i && i.__esModule && Object.prototype.hasOwnProperty.call(i, "default") ? i.default : i;
+}
+var x = { exports: {} }, Se;
+function Ve() {
+  return Se || (Se = 1, (function(i) {
+    var o = (function(n) {
+      var c = Object.prototype, s = c.hasOwnProperty, d = Object.defineProperty || function(r, e, t) {
+        r[e] = t.value;
+      }, p, k = typeof Symbol == "function" ? Symbol : {}, G = k.iterator || "@@iterator", j = k.asyncIterator || "@@asyncIterator", M = k.toStringTag || "@@toStringTag";
+      function O(r, e, t) {
+        return Object.defineProperty(r, e, {
+          value: t,
+          enumerable: !0,
+          configurable: !0,
+          writable: !0
+        }), r[e];
+      }
+      try {
+        O({}, "");
+      } catch {
+        O = function(e, t, u) {
+          return e[t] = u;
+        };
+      }
+      function C(r, e, t, u) {
+        var a = e && e.prototype instanceof y ? e : y, h = Object.create(a.prototype), L = new H(u || []);
+        return d(h, "_invoke", { value: Q(r, t, L) }), h;
+      }
+      n.wrap = C;
+      function D(r, e, t) {
+        try {
+          return { type: "normal", arg: r.call(e, t) };
+        } catch (u) {
+          return { type: "throw", arg: u };
+        }
+      }
+      var z = "suspendedStart", g = "suspendedYield", m = "executing", U = "completed", w = {};
+      function y() {
+      }
+      function R() {
+      }
+      function _() {
+      }
+      var B = {};
+      O(B, G, function() {
+        return this;
+      });
+      var F = Object.getPrototypeOf, W = F && F(F(J([])));
+      W && W !== c && s.call(W, G) && (B = W);
+      var N = _.prototype = y.prototype = Object.create(B);
+      R.prototype = _, d(N, "constructor", { value: _, configurable: !0 }), d(
+        _,
+        "constructor",
+        { value: R, configurable: !0 }
+      ), R.displayName = O(
+        _,
+        M,
+        "GeneratorFunction"
+      );
+      function Y(r) {
+        ["next", "throw", "return"].forEach(function(e) {
+          O(r, e, function(t) {
+            return this._invoke(e, t);
+          });
+        });
+      }
+      n.isGeneratorFunction = function(r) {
+        var e = typeof r == "function" && r.constructor;
+        return e ? e === R || // For the native GeneratorFunction constructor, the best we can
+        // do is to check its .name property.
+        (e.displayName || e.name) === "GeneratorFunction" : !1;
+      }, n.mark = function(r) {
+        return Object.setPrototypeOf ? Object.setPrototypeOf(r, _) : (r.__proto__ = _, O(r, M, "GeneratorFunction")), r.prototype = Object.create(N), r;
+      }, n.awrap = function(r) {
+        return { __await: r };
+      };
+      function $(r, e) {
+        function t(h, L, S, b) {
+          var E = D(r[h], r, L);
+          if (E.type === "throw")
+            b(E.arg);
+          else {
+            var l = E.arg, f = l.value;
+            return f && typeof f == "object" && s.call(f, "__await") ? e.resolve(f.__await).then(function(v) {
+              t("next", v, S, b);
+            }, function(v) {
+              t("throw", v, S, b);
+            }) : e.resolve(f).then(function(v) {
+              l.value = v, S(l);
+            }, function(v) {
+              return t("throw", v, S, b);
+            });
+          }
+        }
+        var u;
+        function a(h, L) {
+          function S() {
+            return new e(function(b, E) {
+              t(h, L, b, E);
+            });
+          }
+          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(
+            S,
+            // Avoid propagating failures to Promises returned by later
+            // invocations of the iterator.
+            S
+          ) : S();
+        }
+        d(this, "_invoke", { value: a });
+      }
+      Y($.prototype), O($.prototype, j, function() {
+        return this;
+      }), n.AsyncIterator = $, n.async = function(r, e, t, u, a) {
+        a === void 0 && (a = Promise);
+        var h = new $(
+          C(r, e, t, u),
+          a
+        );
+        return n.isGeneratorFunction(e) ? h : h.next().then(function(L) {
+          return L.done ? L.value : h.next();
+        });
+      };
+      function Q(r, e, t) {
+        var u = z;
+        return function(h, L) {
+          if (u === m)
+            throw new Error("Generator is already running");
+          if (u === U) {
+            if (h === "throw")
+              throw L;
+            return Z();
+          }
+          for (t.method = h, t.arg = L; ; ) {
+            var S = t.delegate;
+            if (S) {
+              var b = P(S, t);
+              if (b) {
+                if (b === w) continue;
+                return b;
+              }
+            }
+            if (t.method === "next")
+              t.sent = t._sent = t.arg;
+            else if (t.method === "throw") {
+              if (u === z)
+                throw u = U, t.arg;
+              t.dispatchException(t.arg);
+            } else t.method === "return" && t.abrupt("return", t.arg);
+            u = m;
+            var E = D(r, e, t);
+            if (E.type === "normal") {
+              if (u = t.done ? U : g, E.arg === w)
+                continue;
+              return {
+                value: E.arg,
+                done: t.done
+              };
+            } else E.type === "throw" && (u = U, t.method = "throw", t.arg = E.arg);
+          }
+        };
+      }
+      function P(r, e) {
+        var t = e.method, u = r.iterator[t];
+        if (u === p)
+          return e.delegate = null, t === "throw" && r.iterator.return && (e.method = "return", e.arg = p, P(r, e), e.method === "throw") || t !== "return" && (e.method = "throw", e.arg = new TypeError(
+            "The iterator does not provide a '" + t + "' method"
+          )), w;
+        var a = D(u, r.iterator, e.arg);
+        if (a.type === "throw")
+          return e.method = "throw", e.arg = a.arg, e.delegate = null, w;
+        var h = a.arg;
+        if (!h)
+          return e.method = "throw", e.arg = new TypeError("iterator result is not an object"), e.delegate = null, w;
+        if (h.done)
+          e[r.resultName] = h.value, e.next = r.nextLoc, e.method !== "return" && (e.method = "next", e.arg = p);
+        else
+          return h;
+        return e.delegate = null, w;
+      }
+      Y(N), O(N, M, "Generator"), O(N, G, function() {
+        return this;
+      }), O(N, "toString", function() {
+        return "[object Generator]";
+      });
+      function T(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 K(r) {
+        var e = r.completion || {};
+        e.type = "normal", delete e.arg, r.completion = e;
+      }
+      function H(r) {
+        this.tryEntries = [{ tryLoc: "root" }], r.forEach(T, this), this.reset(!0);
+      }
+      n.keys = function(r) {
+        var e = Object(r), t = [];
+        for (var u in e)
+          t.push(u);
+        return t.reverse(), function a() {
+          for (; t.length; ) {
+            var h = t.pop();
+            if (h in e)
+              return a.value = h, a.done = !1, a;
+          }
+          return a.done = !0, a;
+        };
+      };
+      function J(r) {
+        if (r) {
+          var e = r[G];
+          if (e)
+            return e.call(r);
+          if (typeof r.next == "function")
+            return r;
+          if (!isNaN(r.length)) {
+            var t = -1, u = function a() {
+              for (; ++t < r.length; )
+                if (s.call(r, t))
+                  return a.value = r[t], a.done = !1, a;
+              return a.value = p, a.done = !0, a;
+            };
+            return u.next = u;
+          }
+        }
+        return { next: Z };
+      }
+      n.values = J;
+      function Z() {
+        return { value: p, done: !0 };
+      }
+      return H.prototype = {
+        constructor: H,
+        reset: function(r) {
+          if (this.prev = 0, this.next = 0, this.sent = this._sent = p, this.done = !1, this.delegate = null, this.method = "next", this.arg = p, this.tryEntries.forEach(K), !r)
+            for (var e in this)
+              e.charAt(0) === "t" && s.call(this, e) && !isNaN(+e.slice(1)) && (this[e] = p);
+        },
+        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(b, E) {
+            return h.type = "throw", h.arg = r, e.next = b, E && (e.method = "next", e.arg = p), !!E;
+          }
+          for (var u = this.tryEntries.length - 1; u >= 0; --u) {
+            var a = this.tryEntries[u], h = a.completion;
+            if (a.tryLoc === "root")
+              return t("end");
+            if (a.tryLoc <= this.prev) {
+              var L = s.call(a, "catchLoc"), S = s.call(a, "finallyLoc");
+              if (L && S) {
+                if (this.prev < a.catchLoc)
+                  return t(a.catchLoc, !0);
+                if (this.prev < a.finallyLoc)
+                  return t(a.finallyLoc);
+              } else if (L) {
+                if (this.prev < a.catchLoc)
+                  return t(a.catchLoc, !0);
+              } else if (S) {
+                if (this.prev < a.finallyLoc)
+                  return t(a.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 && s.call(u, "finallyLoc") && this.prev < u.finallyLoc) {
+              var a = u;
+              break;
+            }
+          }
+          a && (r === "break" || r === "continue") && a.tryLoc <= e && e <= a.finallyLoc && (a = null);
+          var h = a ? a.completion : {};
+          return h.type = r, h.arg = e, a ? (this.method = "next", this.next = a.finallyLoc, w) : 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), w;
+        },
+        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), K(t), w;
+          }
+        },
+        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 a = u.arg;
+                K(t);
+              }
+              return a;
+            }
+          }
+          throw new Error("illegal catch attempt");
+        },
+        delegateYield: function(r, e, t) {
+          return this.delegate = {
+            iterator: J(r),
+            resultName: e,
+            nextLoc: t
+          }, this.method === "next" && (this.arg = p), w;
+        }
+      }, n;
+    })(
+      // 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.
+      i.exports
+    );
+    try {
+      regeneratorRuntime = o;
+    } catch {
+      typeof globalThis == "object" ? globalThis.regeneratorRuntime = o : Function("r", "regeneratorRuntime = r")(o);
+    }
+  })(x)), x.exports;
+}
+var ee, Ee;
+function we() {
+  return Ee || (Ee = 1, ee = (i, o) => `${i}-${o}-${Math.random().toString(16).slice(3, 8)}`), ee;
+}
+var re, Oe;
+function Fe() {
+  if (Oe) return re;
+  Oe = 1;
+  const i = we();
+  let o = 0;
+  return re = ({
+    id: n,
+    action: c,
+    payload: s = {}
+  }) => {
+    let d = n;
+    return typeof d > "u" && (d = i("Job", o), o += 1), {
+      id: d,
+      action: c,
+      payload: s
+    };
+  }, re;
+}
+var V = {}, Re;
+function Le() {
+  if (Re) return V;
+  Re = 1;
+  let i = !1;
+  return V.logging = i, V.setLogging = (o) => {
+    i = o;
+  }, V.log = (...o) => i ? console.log.apply(this, o) : null, V;
+}
+var te, be;
+function Ze() {
+  if (be) return te;
+  be = 1;
+  const i = Fe(), { log: o } = Le(), n = we();
+  let c = 0;
+  return te = () => {
+    const s = n("Scheduler", c), d = {}, p = {};
+    let k = [];
+    c += 1;
+    const G = () => k.length, j = () => Object.keys(d).length, M = () => {
+      if (k.length !== 0) {
+        const g = Object.keys(d);
+        for (let m = 0; m < g.length; m += 1)
+          if (typeof p[g[m]] > "u") {
+            k[0](d[g[m]]);
+            break;
+          }
+      }
+    }, O = (g, m) => new Promise((U, w) => {
+      const y = i({ action: g, payload: m });
+      k.push(async (R) => {
+        k.shift(), p[R.id] = y;
+        try {
+          U(await R[g].apply(this, [...m, y.id]));
+        } catch (_) {
+          w(_);
+        } finally {
+          delete p[R.id], M();
+        }
+      }), o(`[${s}]: Add ${y.id} to JobQueue`), o(`[${s}]: JobQueue length=${k.length}`), M();
+    });
+    return {
+      addWorker: (g) => (d[g.id] = g, o(`[${s}]: Add ${g.id}`), o(`[${s}]: Number of workers=${j()}`), M(), g.id),
+      addJob: async (g, ...m) => {
+        if (j() === 0)
+          throw Error(`[${s}]: You need to have at least one worker before adding jobs`);
+        return O(g, m);
+      },
+      terminate: async () => {
+        Object.keys(d).forEach(async (g) => {
+          await d[g].terminate();
+        }), k = [];
+      },
+      getQueueLen: G,
+      getNumWorkers: j
+    };
+  }, te;
+}
+function Qe(i) {
+  throw new Error('Could not dynamically require "' + i + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+var ne, ke;
+function Xe() {
+  return ke || (ke = 1, ne = (i) => {
+    const o = {};
+    return typeof WorkerGlobalScope < "u" ? o.type = "webworker" : typeof document == "object" ? o.type = "browser" : typeof process == "object" && typeof Qe == "function" && (o.type = "node"), typeof i > "u" ? o : o[i];
+  }), ne;
+}
+var oe, _e;
+function xe() {
+  if (_e) return oe;
+  _e = 1;
+  const o = Xe()("type") === "browser" ? (n) => new URL(n, window.location.href).href : (n) => n;
+  return oe = (n) => {
+    const c = { ...n };
+    return ["corePath", "workerPath", "langPath"].forEach((s) => {
+      n[s] && (c[s] = o(c[s]));
+    }), c;
+  }, oe;
+}
+var ae, Te;
+function $e() {
+  return Te || (Te = 1, ae = {
+    TESSERACT_ONLY: 0,
+    LSTM_ONLY: 1,
+    TESSERACT_LSTM_COMBINED: 2,
+    DEFAULT: 3
+  }), ae;
+}
+const er = "7.0.0";
+var rr = {
+  version: er
+}, ie, Ae;
+function tr() {
+  return Ae || (Ae = 1, ie = {
+    /*
+     * Use BlobURL for worker script by default
+     * TODO: remove this option
+     *
+     */
+    workerBlobURL: !0,
+    logger: () => {
+    }
+  }), ie;
+}
+var se, qe;
+function nr() {
+  if (qe) return se;
+  qe = 1;
+  const i = rr.version;
+  return se = {
+    ...tr(),
+    workerPath: `https://cdn.jsdelivr.net/npm/tesseract.js@v${i}/dist/worker.min.js`
+  }, se;
+}
+var ue, Ne;
+function or() {
+  return Ne || (Ne = 1, ue = ({ workerPath: i, workerBlobURL: o }) => {
+    let n;
+    if (Blob && URL && o) {
+      const c = new Blob([`importScripts("${i}");`], {
+        type: "application/javascript"
+      });
+      n = new Worker(URL.createObjectURL(c));
+    } else
+      n = new Worker(i);
+    return n;
+  }), ue;
+}
+var ce, Pe;
+function ar() {
+  return Pe || (Pe = 1, ce = (i) => {
+    i.terminate();
+  }), ce;
+}
+var le, Ie;
+function ir() {
+  return Ie || (Ie = 1, le = (i, o) => {
+    i.onmessage = ({ data: n }) => {
+      o(n);
+    };
+  }), le;
+}
+var fe, Me;
+function sr() {
+  return Me || (Me = 1, fe = async (i, o) => {
+    i.postMessage(o);
+  }), fe;
+}
+var de, Ce;
+function ur() {
+  if (Ce) return de;
+  Ce = 1;
+  const i = (n) => new Promise((c, s) => {
+    const d = new FileReader();
+    d.onload = () => {
+      c(d.result);
+    }, d.onerror = ({ target: { error: { code: p } } }) => {
+      s(Error(`File could not be read! Code=${p}`));
+    }, d.readAsArrayBuffer(n);
+  }), o = async (n) => {
+    let c = n;
+    if (typeof n > "u")
+      return "undefined";
+    if (typeof n == "string")
+      /data:image\/([a-zA-Z]*);base64,([^"]*)/.test(n) ? c = atob(n.split(",")[1]).split("").map((s) => s.charCodeAt(0)) : c = await (await fetch(n)).arrayBuffer();
+    else if (typeof HTMLElement < "u" && n instanceof HTMLElement)
+      n.tagName === "IMG" && (c = await o(n.src)), n.tagName === "VIDEO" && (c = await o(n.poster)), n.tagName === "CANVAS" && await new Promise((s) => {
+        n.toBlob(async (d) => {
+          c = await i(d), s();
+        });
+      });
+    else if (typeof OffscreenCanvas < "u" && n instanceof OffscreenCanvas) {
+      const s = await n.convertToBlob();
+      c = await i(s);
+    } else (n instanceof File || n instanceof Blob) && (c = await i(n));
+    return new Uint8Array(c);
+  };
+  return de = o, de;
+}
+var he, Ge;
+function cr() {
+  if (Ge) return he;
+  Ge = 1;
+  const i = nr(), o = or(), n = ar(), c = ir(), s = sr(), d = ur();
+  return he = {
+    defaultOptions: i,
+    spawnWorker: o,
+    terminateWorker: n,
+    onMessage: c,
+    send: s,
+    loadImage: d
+  }, he;
+}
+var pe, je;
+function ze() {
+  if (je) return pe;
+  je = 1;
+  const i = xe(), o = Fe(), { log: n } = Le(), c = we(), s = $e(), {
+    defaultOptions: d,
+    spawnWorker: p,
+    terminateWorker: k,
+    onMessage: G,
+    loadImage: j,
+    send: M
+  } = cr();
+  let O = 0;
+  return pe = async (C = "eng", D = s.LSTM_ONLY, z = {}, g = {}) => {
+    const m = c("Worker", O), {
+      logger: U,
+      errorHandler: w,
+      ...y
+    } = i({
+      ...d,
+      ...z
+    }), R = {}, _ = typeof C == "string" ? C.split("+") : C;
+    let B = D, F = g;
+    const W = [s.DEFAULT, s.LSTM_ONLY].includes(D) && !y.legacyCore;
+    let N, Y;
+    const $ = new Promise((l, f) => {
+      Y = l, N = f;
+    }), Q = (l) => {
+      N(l.message);
+    };
+    let P = p(y);
+    P.onerror = Q, O += 1;
+    const T = ({ id: l, action: f, payload: v }) => new Promise((A, q) => {
+      n(`[${m}]: Start ${l}, action=${f}`);
+      const I = `${f}-${l}`;
+      R[I] = { resolve: A, reject: q }, M(P, {
+        workerId: m,
+        jobId: l,
+        action: f,
+        payload: v
+      });
+    }), K = () => console.warn("`load` is depreciated and should be removed from code (workers now come pre-loaded)"), H = (l) => T(o({
+      id: l,
+      action: "load",
+      payload: { options: { lstmOnly: W, corePath: y.corePath, logging: y.logging } }
+    })), J = (l, f, v) => T(o({
+      id: v,
+      action: "FS",
+      payload: { method: "writeFile", args: [l, f] }
+    })), Z = (l, f) => T(o({
+      id: f,
+      action: "FS",
+      payload: { method: "readFile", args: [l, { encoding: "utf8" }] }
+    })), r = (l, f) => T(o({
+      id: f,
+      action: "FS",
+      payload: { method: "unlink", args: [l] }
+    })), e = (l, f, v) => T(o({
+      id: v,
+      action: "FS",
+      payload: { method: l, args: f }
+    })), t = (l, f) => T(o({
+      id: f,
+      action: "loadLanguage",
+      payload: {
+        langs: l,
+        options: {
+          langPath: y.langPath,
+          dataPath: y.dataPath,
+          cachePath: y.cachePath,
+          cacheMethod: y.cacheMethod,
+          gzip: y.gzip,
+          lstmOnly: [s.DEFAULT, s.LSTM_ONLY].includes(B) && !y.legacyLang
+        }
+      }
+    })), u = (l, f, v, A) => T(o({
+      id: A,
+      action: "initialize",
+      payload: { langs: l, oem: f, config: v }
+    })), a = (l = "eng", f, v, A) => {
+      if (W && [s.TESSERACT_ONLY, s.TESSERACT_LSTM_COMBINED].includes(f)) throw Error("Legacy model requested but code missing.");
+      const q = f || B;
+      B = q;
+      const I = v || F;
+      F = I;
+      const X = (typeof l == "string" ? l.split("+") : l).filter((Ke) => !_.includes(Ke));
+      return _.push(...X), X.length > 0 ? t(X, A).then(() => u(l, q, I, A)) : u(l, q, I, A);
+    }, h = (l = {}, f) => T(o({
+      id: f,
+      action: "setParameters",
+      payload: { params: l }
+    })), L = async (l, f = {}, v = {
+      text: !0
+    }, A) => T(o({
+      id: A,
+      action: "recognize",
+      payload: { image: await j(l), options: f, output: v }
+    })), S = async (l, f) => {
+      if (W) throw Error("`worker.detect` requires Legacy model, which was not loaded.");
+      return T(o({
+        id: f,
+        action: "detect",
+        payload: { image: await j(l) }
+      }));
+    }, b = async () => (P !== null && (k(P), P = null), Promise.resolve());
+    G(P, ({
+      workerId: l,
+      jobId: f,
+      status: v,
+      action: A,
+      data: q
+    }) => {
+      const I = `${A}-${f}`;
+      if (v === "resolve")
+        n(`[${l}]: Complete ${f}`), R[I].resolve({ jobId: f, data: q }), delete R[I];
+      else if (v === "reject")
+        if (R[I].reject(q), delete R[I], A === "load" && N(q), w)
+          w(q);
+        else
+          throw Error(q);
+      else v === "progress" && U({ ...q, userJobId: f });
+    });
+    const E = {
+      id: m,
+      worker: P,
+      load: K,
+      writeText: J,
+      readText: Z,
+      removeFile: r,
+      FS: e,
+      reinitialize: a,
+      setParameters: h,
+      recognize: L,
+      detect: S,
+      terminate: b
+    };
+    return H().then(() => t(C)).then(() => u(C, D, g)).then(() => Y(E)).catch(() => {
+    }), $;
+  }, pe;
+}
+var ve, De;
+function lr() {
+  if (De) return ve;
+  De = 1;
+  const i = ze();
+  return ve = {
+    recognize: async (c, s, d) => {
+      const p = await i(s, 1, d);
+      return p.recognize(c).finally(async () => {
+        await p.terminate();
+      });
+    },
+    detect: async (c, s) => {
+      const d = await i("osd", 0, s);
+      return d.detect(c).finally(async () => {
+        await d.terminate();
+      });
+    }
+  }, ve;
+}
+var ge, Ue;
+function fr() {
+  return Ue || (Ue = 1, ge = {
+    AFR: "afr",
+    AMH: "amh",
+    ARA: "ara",
+    ASM: "asm",
+    AZE: "aze",
+    AZE_CYRL: "aze_cyrl",
+    BEL: "bel",
+    BEN: "ben",
+    BOD: "bod",
+    BOS: "bos",
+    BUL: "bul",
+    CAT: "cat",
+    CEB: "ceb",
+    CES: "ces",
+    CHI_SIM: "chi_sim",
+    CHI_TRA: "chi_tra",
+    CHR: "chr",
+    CYM: "cym",
+    DAN: "dan",
+    DEU: "deu",
+    DZO: "dzo",
+    ELL: "ell",
+    ENG: "eng",
+    ENM: "enm",
+    EPO: "epo",
+    EST: "est",
+    EUS: "eus",
+    FAS: "fas",
+    FIN: "fin",
+    FRA: "fra",
+    FRK: "frk",
+    FRM: "frm",
+    GLE: "gle",
+    GLG: "glg",
+    GRC: "grc",
+    GUJ: "guj",
+    HAT: "hat",
+    HEB: "heb",
+    HIN: "hin",
+    HRV: "hrv",
+    HUN: "hun",
+    IKU: "iku",
+    IND: "ind",
+    ISL: "isl",
+    ITA: "ita",
+    ITA_OLD: "ita_old",
+    JAV: "jav",
+    JPN: "jpn",
+    KAN: "kan",
+    KAT: "kat",
+    KAT_OLD: "kat_old",
+    KAZ: "kaz",
+    KHM: "khm",
+    KIR: "kir",
+    KOR: "kor",
+    KUR: "kur",
+    LAO: "lao",
+    LAT: "lat",
+    LAV: "lav",
+    LIT: "lit",
+    MAL: "mal",
+    MAR: "mar",
+    MKD: "mkd",
+    MLT: "mlt",
+    MSA: "msa",
+    MYA: "mya",
+    NEP: "nep",
+    NLD: "nld",
+    NOR: "nor",
+    ORI: "ori",
+    PAN: "pan",
+    POL: "pol",
+    POR: "por",
+    PUS: "pus",
+    RON: "ron",
+    RUS: "rus",
+    SAN: "san",
+    SIN: "sin",
+    SLK: "slk",
+    SLV: "slv",
+    SPA: "spa",
+    SPA_OLD: "spa_old",
+    SQI: "sqi",
+    SRP: "srp",
+    SRP_LATN: "srp_latn",
+    SWA: "swa",
+    SWE: "swe",
+    SYR: "syr",
+    TAM: "tam",
+    TEL: "tel",
+    TGK: "tgk",
+    TGL: "tgl",
+    THA: "tha",
+    TIR: "tir",
+    TUR: "tur",
+    UIG: "uig",
+    UKR: "ukr",
+    URD: "urd",
+    UZB: "uzb",
+    UZB_CYRL: "uzb_cyrl",
+    VIE: "vie",
+    YID: "yid"
+  }), ge;
+}
+var ye, We;
+function dr() {
+  return We || (We = 1, ye = {
+    OSD_ONLY: "0",
+    AUTO_OSD: "1",
+    AUTO_ONLY: "2",
+    AUTO: "3",
+    SINGLE_COLUMN: "4",
+    SINGLE_BLOCK_VERT_TEXT: "5",
+    SINGLE_BLOCK: "6",
+    SINGLE_LINE: "7",
+    SINGLE_WORD: "8",
+    CIRCLE_WORD: "9",
+    SINGLE_CHAR: "10",
+    SPARSE_TEXT: "11",
+    SPARSE_TEXT_OSD: "12",
+    RAW_LINE: "13"
+  }), ye;
+}
+var me, Be;
+function hr() {
+  if (Be) return me;
+  Be = 1, Ve();
+  const i = Ze(), o = ze(), n = lr(), c = fr(), s = $e(), d = dr(), { setLogging: p } = Le();
+  return me = {
+    languages: c,
+    OEM: s,
+    PSM: d,
+    createScheduler: i,
+    createWorker: o,
+    setLogging: p,
+    ...n
+  }, me;
+}
+var Ye = hr(), pr = /* @__PURE__ */ Je(Ye), gr = /* @__PURE__ */ He({
+  __proto__: null,
+  default: pr
+}, [Ye]);
+export {
+  gr as i
+};
+//# sourceMappingURL=index-C62fEJ4q.js.map