ranuts 0.1.0-alpha.17 → 0.1.0-alpha.18

package/dist/src/ml/index.js

@@ -1,1291 +1,1229 @@
 var runtime = { exports: {} };
-(function(module) {
-  var runtime2 = function(exports) {
-    var Op = Object.prototype;
-    var hasOwn = Op.hasOwnProperty;
-    var defineProperty = Object.defineProperty || function(obj, key, desc) {
-      obj[key] = desc.value;
-    };
-    var undefined$1;
-    var $Symbol = typeof Symbol === "function" ? Symbol : {};
-    var iteratorSymbol = $Symbol.iterator || "@@iterator";
-    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
-    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-    function define(obj, key, value) {
-      Object.defineProperty(obj, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-      return obj[key];
-    }
-    try {
-      define({}, "");
-    } catch (err) {
-      define = function(obj, key, value) {
-        return obj[key] = value;
+var hasRequiredRuntime;
+function requireRuntime() {
+  if (hasRequiredRuntime) return runtime.exports;
+  hasRequiredRuntime = 1;
+  (function(module) {
+    var runtime2 = function(exports) {
+      var Op = Object.prototype;
+      var hasOwn = Op.hasOwnProperty;
+      var defineProperty = Object.defineProperty || function(obj, key, desc) {
+        obj[key] = desc.value;
       };
-    }
-    function wrap(innerFn, outerFn, self, tryLocsList) {
-      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
-      var generator = Object.create(protoGenerator.prototype);
-      var context = new Context(tryLocsList || []);
-      defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) });
-      return generator;
-    }
-    exports.wrap = wrap;
-    function tryCatch(fn, obj, arg) {
+      var undefined$1;
+      var $Symbol = typeof Symbol === "function" ? Symbol : {};
+      var iteratorSymbol = $Symbol.iterator || "@@iterator";
+      var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+      var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+      function define(obj, key, value) {
+        Object.defineProperty(obj, key, {
+          value,
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+        return obj[key];
+      }
       try {
-        return { type: "normal", arg: fn.call(obj, arg) };
+        define({}, "");
       } catch (err) {
-        return { type: "throw", arg: err };
+        define = function(obj, key, value) {
+          return obj[key] = value;
+        };
       }
-    }
-    var GenStateSuspendedStart = "suspendedStart";
-    var GenStateSuspendedYield = "suspendedYield";
-    var GenStateExecuting = "executing";
-    var GenStateCompleted = "completed";
-    var ContinueSentinel = {};
-    function Generator() {
-    }
-    function GeneratorFunction() {
-    }
-    function GeneratorFunctionPrototype() {
-    }
-    var IteratorPrototype = {};
-    define(IteratorPrototype, iteratorSymbol, function() {
-      return this;
-    });
-    var getProto = Object.getPrototypeOf;
-    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-    if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
-      IteratorPrototype = NativeIteratorPrototype;
-    }
-    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-    GeneratorFunction.prototype = GeneratorFunctionPrototype;
-    defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: true });
-    defineProperty(
-      GeneratorFunctionPrototype,
-      "constructor",
-      { value: GeneratorFunction, configurable: true }
-    );
-    GeneratorFunction.displayName = define(
-      GeneratorFunctionPrototype,
-      toStringTagSymbol,
-      "GeneratorFunction"
-    );
-    function defineIteratorMethods(prototype) {
-      ["next", "throw", "return"].forEach(function(method) {
-        define(prototype, method, function(arg) {
-          return this._invoke(method, arg);
-        });
+      function wrap(innerFn, outerFn, self, tryLocsList) {
+        var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+        var generator = Object.create(protoGenerator.prototype);
+        var context = new Context(tryLocsList || []);
+        defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) });
+        return generator;
+      }
+      exports.wrap = wrap;
+      function tryCatch(fn, obj, arg) {
+        try {
+          return { type: "normal", arg: fn.call(obj, arg) };
+        } catch (err) {
+          return { type: "throw", arg: err };
+        }
+      }
+      var GenStateSuspendedStart = "suspendedStart";
+      var GenStateSuspendedYield = "suspendedYield";
+      var GenStateExecuting = "executing";
+      var GenStateCompleted = "completed";
+      var ContinueSentinel = {};
+      function Generator() {
+      }
+      function GeneratorFunction() {
+      }
+      function GeneratorFunctionPrototype() {
+      }
+      var IteratorPrototype = {};
+      define(IteratorPrototype, iteratorSymbol, function() {
+        return this;
       });
-    }
-    exports.isGeneratorFunction = function(genFun) {
-      var ctor = typeof genFun === "function" && genFun.constructor;
-      return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can
-      // do is to check its .name property.
-      (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
-    };
-    exports.mark = function(genFun) {
-      if (Object.setPrototypeOf) {
-        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
-      } else {
-        genFun.__proto__ = GeneratorFunctionPrototype;
-        define(genFun, toStringTagSymbol, "GeneratorFunction");
+      var getProto = Object.getPrototypeOf;
+      var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+      if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+        IteratorPrototype = NativeIteratorPrototype;
       }
-      genFun.prototype = Object.create(Gp);
-      return genFun;
-    };
-    exports.awrap = function(arg) {
-      return { __await: arg };
-    };
-    function AsyncIterator(generator, PromiseImpl) {
-      function invoke(method, arg, resolve, reject) {
-        var record = tryCatch(generator[method], generator, arg);
-        if (record.type === "throw") {
-          reject(record.arg);
+      var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+      GeneratorFunction.prototype = GeneratorFunctionPrototype;
+      defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: true });
+      defineProperty(
+        GeneratorFunctionPrototype,
+        "constructor",
+        { value: GeneratorFunction, configurable: true }
+      );
+      GeneratorFunction.displayName = define(
+        GeneratorFunctionPrototype,
+        toStringTagSymbol,
+        "GeneratorFunction"
+      );
+      function defineIteratorMethods(prototype) {
+        ["next", "throw", "return"].forEach(function(method) {
+          define(prototype, method, function(arg) {
+            return this._invoke(method, arg);
+          });
+        });
+      }
+      exports.isGeneratorFunction = function(genFun) {
+        var ctor = typeof genFun === "function" && genFun.constructor;
+        return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can
+        // do is to check its .name property.
+        (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+      };
+      exports.mark = function(genFun) {
+        if (Object.setPrototypeOf) {
+          Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
         } else {
-          var result = record.arg;
-          var value = result.value;
-          if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
-            return PromiseImpl.resolve(value.__await).then(function(value2) {
-              invoke("next", value2, resolve, reject);
-            }, function(err) {
-              invoke("throw", err, resolve, reject);
+          genFun.__proto__ = GeneratorFunctionPrototype;
+          define(genFun, toStringTagSymbol, "GeneratorFunction");
+        }
+        genFun.prototype = Object.create(Gp);
+        return genFun;
+      };
+      exports.awrap = function(arg) {
+        return { __await: arg };
+      };
+      function AsyncIterator(generator, PromiseImpl) {
+        function invoke(method, arg, resolve, reject) {
+          var record = tryCatch(generator[method], generator, arg);
+          if (record.type === "throw") {
+            reject(record.arg);
+          } else {
+            var result = record.arg;
+            var value = result.value;
+            if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
+              return PromiseImpl.resolve(value.__await).then(function(value2) {
+                invoke("next", value2, resolve, reject);
+              }, function(err) {
+                invoke("throw", err, resolve, reject);
+              });
+            }
+            return PromiseImpl.resolve(value).then(function(unwrapped) {
+              result.value = unwrapped;
+              resolve(result);
+            }, function(error) {
+              return invoke("throw", error, resolve, reject);
             });
           }
-          return PromiseImpl.resolve(value).then(function(unwrapped) {
-            result.value = unwrapped;
-            resolve(result);
-          }, function(error) {
-            return invoke("throw", error, resolve, reject);
-          });
         }
-      }
-      var previousPromise;
-      function enqueue(method, arg) {
-        function callInvokeWithMethodAndArg() {
-          return new PromiseImpl(function(resolve, reject) {
-            invoke(method, arg, resolve, reject);
-          });
+        var previousPromise;
+        function enqueue(method, arg) {
+          function callInvokeWithMethodAndArg() {
+            return new PromiseImpl(function(resolve, reject) {
+              invoke(method, arg, resolve, reject);
+            });
+          }
+          return previousPromise = // 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.
+          previousPromise ? previousPromise.then(
+            callInvokeWithMethodAndArg,
+            // Avoid propagating failures to Promises returned by later
+            // invocations of the iterator.
+            callInvokeWithMethodAndArg
+          ) : callInvokeWithMethodAndArg();
         }
-        return previousPromise = // 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.
-        previousPromise ? previousPromise.then(
-          callInvokeWithMethodAndArg,
-          // Avoid propagating failures to Promises returned by later
-          // invocations of the iterator.
-          callInvokeWithMethodAndArg
-        ) : callInvokeWithMethodAndArg();
+        defineProperty(this, "_invoke", { value: enqueue });
       }
-      defineProperty(this, "_invoke", { value: enqueue });
-    }
-    defineIteratorMethods(AsyncIterator.prototype);
-    define(AsyncIterator.prototype, asyncIteratorSymbol, function() {
-      return this;
-    });
-    exports.AsyncIterator = AsyncIterator;
-    exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-      if (PromiseImpl === void 0) PromiseImpl = Promise;
-      var iter = new AsyncIterator(
-        wrap(innerFn, outerFn, self, tryLocsList),
-        PromiseImpl
-      );
-      return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function(result) {
-        return result.done ? result.value : iter.next();
+      defineIteratorMethods(AsyncIterator.prototype);
+      define(AsyncIterator.prototype, asyncIteratorSymbol, function() {
+        return this;
       });
-    };
-    function makeInvokeMethod(innerFn, self, context) {
-      var state = GenStateSuspendedStart;
-      return function invoke(method, arg) {
-        if (state === GenStateExecuting) {
-          throw new Error("Generator is already running");
-        }
-        if (state === GenStateCompleted) {
-          if (method === "throw") {
-            throw arg;
+      exports.AsyncIterator = AsyncIterator;
+      exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+        if (PromiseImpl === void 0) PromiseImpl = Promise;
+        var iter = new AsyncIterator(
+          wrap(innerFn, outerFn, self, tryLocsList),
+          PromiseImpl
+        );
+        return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function(result) {
+          return result.done ? result.value : iter.next();
+        });
+      };
+      function makeInvokeMethod(innerFn, self, context) {
+        var state = GenStateSuspendedStart;
+        return function invoke(method, arg) {
+          if (state === GenStateExecuting) {
+            throw new Error("Generator is already running");
           }
-          return doneResult();
-        }
-        context.method = method;
-        context.arg = arg;
-        while (true) {
-          var delegate = context.delegate;
-          if (delegate) {
-            var delegateResult = maybeInvokeDelegate(delegate, context);
-            if (delegateResult) {
-              if (delegateResult === ContinueSentinel) continue;
-              return delegateResult;
+          if (state === GenStateCompleted) {
+            if (method === "throw") {
+              throw arg;
             }
+            return doneResult();
           }
-          if (context.method === "next") {
-            context.sent = context._sent = context.arg;
-          } else if (context.method === "throw") {
-            if (state === GenStateSuspendedStart) {
+          context.method = method;
+          context.arg = arg;
+          while (true) {
+            var delegate = context.delegate;
+            if (delegate) {
+              var delegateResult = maybeInvokeDelegate(delegate, context);
+              if (delegateResult) {
+                if (delegateResult === ContinueSentinel) continue;
+                return delegateResult;
+              }
+            }
+            if (context.method === "next") {
+              context.sent = context._sent = context.arg;
+            } else if (context.method === "throw") {
+              if (state === GenStateSuspendedStart) {
+                state = GenStateCompleted;
+                throw context.arg;
+              }
+              context.dispatchException(context.arg);
+            } else if (context.method === "return") {
+              context.abrupt("return", context.arg);
+            }
+            state = GenStateExecuting;
+            var record = tryCatch(innerFn, self, context);
+            if (record.type === "normal") {
+              state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+              if (record.arg === ContinueSentinel) {
+                continue;
+              }
+              return {
+                value: record.arg,
+                done: context.done
+              };
+            } else if (record.type === "throw") {
               state = GenStateCompleted;
-              throw context.arg;
+              context.method = "throw";
+              context.arg = record.arg;
             }
-            context.dispatchException(context.arg);
-          } else if (context.method === "return") {
-            context.abrupt("return", context.arg);
           }
-          state = GenStateExecuting;
-          var record = tryCatch(innerFn, self, context);
-          if (record.type === "normal") {
-            state = context.done ? GenStateCompleted : GenStateSuspendedYield;
-            if (record.arg === ContinueSentinel) {
-              continue;
+        };
+      }
+      function maybeInvokeDelegate(delegate, context) {
+        var methodName = context.method;
+        var method = delegate.iterator[methodName];
+        if (method === undefined$1) {
+          context.delegate = null;
+          if (methodName === "throw" && delegate.iterator["return"]) {
+            context.method = "return";
+            context.arg = undefined$1;
+            maybeInvokeDelegate(delegate, context);
+            if (context.method === "throw") {
+              return ContinueSentinel;
             }
-            return {
-              value: record.arg,
-              done: context.done
-            };
-          } else if (record.type === "throw") {
-            state = GenStateCompleted;
+          }
+          if (methodName !== "return") {
             context.method = "throw";
-            context.arg = record.arg;
+            context.arg = new TypeError(
+              "The iterator does not provide a '" + methodName + "' method"
+            );
           }
+          return ContinueSentinel;
         }
-      };
-    }
-    function maybeInvokeDelegate(delegate, context) {
-      var methodName = context.method;
-      var method = delegate.iterator[methodName];
-      if (method === undefined$1) {
-        context.delegate = null;
-        if (methodName === "throw" && delegate.iterator["return"]) {
-          context.method = "return";
-          context.arg = undefined$1;
-          maybeInvokeDelegate(delegate, context);
-          if (context.method === "throw") {
-            return ContinueSentinel;
-          }
+        var record = tryCatch(method, delegate.iterator, context.arg);
+        if (record.type === "throw") {
+          context.method = "throw";
+          context.arg = record.arg;
+          context.delegate = null;
+          return ContinueSentinel;
         }
-        if (methodName !== "return") {
+        var info = record.arg;
+        if (!info) {
           context.method = "throw";
-          context.arg = new TypeError(
-            "The iterator does not provide a '" + methodName + "' method"
-          );
+          context.arg = new TypeError("iterator result is not an object");
+          context.delegate = null;
+          return ContinueSentinel;
+        }
+        if (info.done) {
+          context[delegate.resultName] = info.value;
+          context.next = delegate.nextLoc;
+          if (context.method !== "return") {
+            context.method = "next";
+            context.arg = undefined$1;
+          }
+        } else {
+          return info;
         }
-        return ContinueSentinel;
-      }
-      var record = tryCatch(method, delegate.iterator, context.arg);
-      if (record.type === "throw") {
-        context.method = "throw";
-        context.arg = record.arg;
-        context.delegate = null;
-        return ContinueSentinel;
-      }
-      var info = record.arg;
-      if (!info) {
-        context.method = "throw";
-        context.arg = new TypeError("iterator result is not an object");
         context.delegate = null;
         return ContinueSentinel;
       }
-      if (info.done) {
-        context[delegate.resultName] = info.value;
-        context.next = delegate.nextLoc;
-        if (context.method !== "return") {
-          context.method = "next";
-          context.arg = undefined$1;
+      defineIteratorMethods(Gp);
+      define(Gp, toStringTagSymbol, "Generator");
+      define(Gp, iteratorSymbol, function() {
+        return this;
+      });
+      define(Gp, "toString", function() {
+        return "[object Generator]";
+      });
+      function pushTryEntry(locs) {
+        var entry = { tryLoc: locs[0] };
+        if (1 in locs) {
+          entry.catchLoc = locs[1];
         }
-      } else {
-        return info;
+        if (2 in locs) {
+          entry.finallyLoc = locs[2];
+          entry.afterLoc = locs[3];
+        }
+        this.tryEntries.push(entry);
       }
-      context.delegate = null;
-      return ContinueSentinel;
-    }
-    defineIteratorMethods(Gp);
-    define(Gp, toStringTagSymbol, "Generator");
-    define(Gp, iteratorSymbol, function() {
-      return this;
-    });
-    define(Gp, "toString", function() {
-      return "[object Generator]";
-    });
-    function pushTryEntry(locs) {
-      var entry = { tryLoc: locs[0] };
-      if (1 in locs) {
-        entry.catchLoc = locs[1];
+      function resetTryEntry(entry) {
+        var record = entry.completion || {};
+        record.type = "normal";
+        delete record.arg;
+        entry.completion = record;
       }
-      if (2 in locs) {
-        entry.finallyLoc = locs[2];
-        entry.afterLoc = locs[3];
+      function Context(tryLocsList) {
+        this.tryEntries = [{ tryLoc: "root" }];
+        tryLocsList.forEach(pushTryEntry, this);
+        this.reset(true);
       }
-      this.tryEntries.push(entry);
-    }
-    function resetTryEntry(entry) {
-      var record = entry.completion || {};
-      record.type = "normal";
-      delete record.arg;
-      entry.completion = record;
-    }
-    function Context(tryLocsList) {
-      this.tryEntries = [{ tryLoc: "root" }];
-      tryLocsList.forEach(pushTryEntry, this);
-      this.reset(true);
-    }
-    exports.keys = function(val) {
-      var object = Object(val);
-      var keys = [];
-      for (var key in object) {
-        keys.push(key);
-      }
-      keys.reverse();
-      return function next() {
-        while (keys.length) {
-          var key2 = keys.pop();
-          if (key2 in object) {
-            next.value = key2;
-            next.done = false;
-            return next;
-          }
+      exports.keys = function(val) {
+        var object = Object(val);
+        var keys = [];
+        for (var key in object) {
+          keys.push(key);
         }
-        next.done = true;
-        return next;
+        keys.reverse();
+        return function next() {
+          while (keys.length) {
+            var key2 = keys.pop();
+            if (key2 in object) {
+              next.value = key2;
+              next.done = false;
+              return next;
+            }
+          }
+          next.done = true;
+          return next;
+        };
       };
-    };
-    function values(iterable) {
-      if (iterable) {
-        var iteratorMethod = iterable[iteratorSymbol];
-        if (iteratorMethod) {
-          return iteratorMethod.call(iterable);
-        }
-        if (typeof iterable.next === "function") {
-          return iterable;
-        }
-        if (!isNaN(iterable.length)) {
-          var i = -1, next = function next2() {
-            while (++i < iterable.length) {
-              if (hasOwn.call(iterable, i)) {
-                next2.value = iterable[i];
-                next2.done = false;
-                return next2;
+      function values(iterable) {
+        if (iterable) {
+          var iteratorMethod = iterable[iteratorSymbol];
+          if (iteratorMethod) {
+            return iteratorMethod.call(iterable);
+          }
+          if (typeof iterable.next === "function") {
+            return iterable;
+          }
+          if (!isNaN(iterable.length)) {
+            var i = -1, next = function next2() {
+              while (++i < iterable.length) {
+                if (hasOwn.call(iterable, i)) {
+                  next2.value = iterable[i];
+                  next2.done = false;
+                  return next2;
+                }
               }
-            }
-            next2.value = undefined$1;
-            next2.done = true;
-            return next2;
-          };
-          return next.next = next;
+              next2.value = undefined$1;
+              next2.done = true;
+              return next2;
+            };
+            return next.next = next;
+          }
         }
+        return { next: doneResult };
       }
-      return { next: doneResult };
-    }
-    exports.values = values;
-    function doneResult() {
-      return { value: undefined$1, done: true };
-    }
-    Context.prototype = {
-      constructor: Context,
-      reset: function(skipTempReset) {
-        this.prev = 0;
-        this.next = 0;
-        this.sent = this._sent = undefined$1;
-        this.done = false;
-        this.delegate = null;
-        this.method = "next";
-        this.arg = undefined$1;
-        this.tryEntries.forEach(resetTryEntry);
-        if (!skipTempReset) {
-          for (var name2 in this) {
-            if (name2.charAt(0) === "t" && hasOwn.call(this, name2) && !isNaN(+name2.slice(1))) {
-              this[name2] = undefined$1;
+      exports.values = values;
+      function doneResult() {
+        return { value: undefined$1, done: true };
+      }
+      Context.prototype = {
+        constructor: Context,
+        reset: function(skipTempReset) {
+          this.prev = 0;
+          this.next = 0;
+          this.sent = this._sent = undefined$1;
+          this.done = false;
+          this.delegate = null;
+          this.method = "next";
+          this.arg = undefined$1;
+          this.tryEntries.forEach(resetTryEntry);
+          if (!skipTempReset) {
+            for (var name in this) {
+              if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+                this[name] = undefined$1;
+              }
             }
           }
-        }
-      },
-      stop: function() {
-        this.done = true;
-        var rootEntry = this.tryEntries[0];
-        var rootRecord = rootEntry.completion;
-        if (rootRecord.type === "throw") {
-          throw rootRecord.arg;
-        }
-        return this.rval;
-      },
-      dispatchException: function(exception) {
-        if (this.done) {
-          throw exception;
-        }
-        var context = this;
-        function handle(loc, caught) {
-          record.type = "throw";
-          record.arg = exception;
-          context.next = loc;
-          if (caught) {
-            context.method = "next";
-            context.arg = undefined$1;
+        },
+        stop: function() {
+          this.done = true;
+          var rootEntry = this.tryEntries[0];
+          var rootRecord = rootEntry.completion;
+          if (rootRecord.type === "throw") {
+            throw rootRecord.arg;
           }
-          return !!caught;
-        }
-        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i];
-          var record = entry.completion;
-          if (entry.tryLoc === "root") {
-            return handle("end");
+          return this.rval;
+        },
+        dispatchException: function(exception) {
+          if (this.done) {
+            throw exception;
           }
-          if (entry.tryLoc <= this.prev) {
-            var hasCatch = hasOwn.call(entry, "catchLoc");
-            var hasFinally = hasOwn.call(entry, "finallyLoc");
-            if (hasCatch && hasFinally) {
-              if (this.prev < entry.catchLoc) {
-                return handle(entry.catchLoc, true);
-              } else if (this.prev < entry.finallyLoc) {
-                return handle(entry.finallyLoc);
-              }
-            } else if (hasCatch) {
-              if (this.prev < entry.catchLoc) {
-                return handle(entry.catchLoc, true);
-              }
-            } else if (hasFinally) {
-              if (this.prev < entry.finallyLoc) {
-                return handle(entry.finallyLoc);
+          var context = this;
+          function handle(loc, caught) {
+            record.type = "throw";
+            record.arg = exception;
+            context.next = loc;
+            if (caught) {
+              context.method = "next";
+              context.arg = undefined$1;
+            }
+            return !!caught;
+          }
+          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+            var entry = this.tryEntries[i];
+            var record = entry.completion;
+            if (entry.tryLoc === "root") {
+              return handle("end");
+            }
+            if (entry.tryLoc <= this.prev) {
+              var hasCatch = hasOwn.call(entry, "catchLoc");
+              var hasFinally = hasOwn.call(entry, "finallyLoc");
+              if (hasCatch && hasFinally) {
+                if (this.prev < entry.catchLoc) {
+                  return handle(entry.catchLoc, true);
+                } else if (this.prev < entry.finallyLoc) {
+                  return handle(entry.finallyLoc);
+                }
+              } else if (hasCatch) {
+                if (this.prev < entry.catchLoc) {
+                  return handle(entry.catchLoc, true);
+                }
+              } else if (hasFinally) {
+                if (this.prev < entry.finallyLoc) {
+                  return handle(entry.finallyLoc);
+                }
+              } else {
+                throw new Error("try statement without catch or finally");
               }
-            } else {
-              throw new Error("try statement without catch or finally");
             }
           }
-        }
-      },
-      abrupt: function(type, arg) {
-        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i];
-          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-            var finallyEntry = entry;
-            break;
+        },
+        abrupt: function(type, arg) {
+          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+            var entry = this.tryEntries[i];
+            if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+              var finallyEntry = entry;
+              break;
+            }
           }
-        }
-        if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
-          finallyEntry = null;
-        }
-        var record = finallyEntry ? finallyEntry.completion : {};
-        record.type = type;
-        record.arg = arg;
-        if (finallyEntry) {
-          this.method = "next";
-          this.next = finallyEntry.finallyLoc;
-          return ContinueSentinel;
-        }
-        return this.complete(record);
-      },
-      complete: function(record, afterLoc) {
-        if (record.type === "throw") {
-          throw record.arg;
-        }
-        if (record.type === "break" || record.type === "continue") {
-          this.next = record.arg;
-        } else if (record.type === "return") {
-          this.rval = this.arg = record.arg;
-          this.method = "return";
-          this.next = "end";
-        } else if (record.type === "normal" && afterLoc) {
-          this.next = afterLoc;
-        }
-        return ContinueSentinel;
-      },
-      finish: function(finallyLoc) {
-        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i];
-          if (entry.finallyLoc === finallyLoc) {
-            this.complete(entry.completion, entry.afterLoc);
-            resetTryEntry(entry);
+          if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+            finallyEntry = null;
+          }
+          var record = finallyEntry ? finallyEntry.completion : {};
+          record.type = type;
+          record.arg = arg;
+          if (finallyEntry) {
+            this.method = "next";
+            this.next = finallyEntry.finallyLoc;
             return ContinueSentinel;
           }
-        }
-      },
-      "catch": function(tryLoc) {
-        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-          var entry = this.tryEntries[i];
-          if (entry.tryLoc === tryLoc) {
-            var record = entry.completion;
-            if (record.type === "throw") {
-              var thrown = record.arg;
+          return this.complete(record);
+        },
+        complete: function(record, afterLoc) {
+          if (record.type === "throw") {
+            throw record.arg;
+          }
+          if (record.type === "break" || record.type === "continue") {
+            this.next = record.arg;
+          } else if (record.type === "return") {
+            this.rval = this.arg = record.arg;
+            this.method = "return";
+            this.next = "end";
+          } else if (record.type === "normal" && afterLoc) {
+            this.next = afterLoc;
+          }
+          return ContinueSentinel;
+        },
+        finish: function(finallyLoc) {
+          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+            var entry = this.tryEntries[i];
+            if (entry.finallyLoc === finallyLoc) {
+              this.complete(entry.completion, entry.afterLoc);
               resetTryEntry(entry);
+              return ContinueSentinel;
             }
-            return thrown;
           }
+        },
+        "catch": function(tryLoc) {
+          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+            var entry = this.tryEntries[i];
+            if (entry.tryLoc === tryLoc) {
+              var record = entry.completion;
+              if (record.type === "throw") {
+                var thrown = record.arg;
+                resetTryEntry(entry);
+              }
+              return thrown;
+            }
+          }
+          throw new Error("illegal catch attempt");
+        },
+        delegateYield: function(iterable, resultName, nextLoc) {
+          this.delegate = {
+            iterator: values(iterable),
+            resultName,
+            nextLoc
+          };
+          if (this.method === "next") {
+            this.arg = undefined$1;
+          }
+          return ContinueSentinel;
         }
-        throw new Error("illegal catch attempt");
-      },
-      delegateYield: function(iterable, resultName, nextLoc) {
-        this.delegate = {
-          iterator: values(iterable),
-          resultName,
-          nextLoc
-        };
-        if (this.method === "next") {
-          this.arg = undefined$1;
-        }
-        return ContinueSentinel;
+      };
+      return exports;
+    }(
+      // 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.
+      module.exports
+    );
+    try {
+      regeneratorRuntime = runtime2;
+    } catch (accidentalStrictMode) {
+      if (typeof globalThis === "object") {
+        globalThis.regeneratorRuntime = runtime2;
+      } else {
+        Function("r", "regeneratorRuntime = r")(runtime2);
       }
-    };
-    return exports;
-  }(
-    // 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.
-    module.exports
-  );
-  try {
-    regeneratorRuntime = runtime2;
-  } catch (accidentalStrictMode) {
-    if (typeof globalThis === "object") {
-      globalThis.regeneratorRuntime = runtime2;
-    } else {
-      Function("r", "regeneratorRuntime = r")(runtime2);
     }
-  }
-})(runtime);
-var getId$3 = (prefix, cnt) => `${prefix}-${cnt}-${Math.random().toString(16).slice(3, 8)}`;
-const getId$2 = getId$3;
-let jobCounter = 0;
-var createJob$2 = ({
-  id: _id,
-  action,
-  payload = {}
-}) => {
-  let id = _id;
-  if (typeof id === "undefined") {
-    id = getId$2("Job", jobCounter);
-    jobCounter += 1;
-  }
-  return {
-    id,
+  })(runtime);
+  return runtime.exports;
+}
+var getId;
+var hasRequiredGetId;
+function requireGetId() {
+  if (hasRequiredGetId) return getId;
+  hasRequiredGetId = 1;
+  getId = (prefix, cnt) => `${prefix}-${cnt}-${Math.random().toString(16).slice(3, 8)}`;
+  return getId;
+}
+var createJob;
+var hasRequiredCreateJob;
+function requireCreateJob() {
+  if (hasRequiredCreateJob) return createJob;
+  hasRequiredCreateJob = 1;
+  const getId2 = requireGetId();
+  let jobCounter = 0;
+  createJob = ({
+    id: _id,
     action,
-    payload
-  };
-};
-var log$2 = {};
-let logging = false;
-log$2.logging = logging;
-log$2.setLogging = (_logging) => {
-  logging = _logging;
-};
-log$2.log = (...args) => logging ? console.log.apply(void 0, args) : null;
-const createJob$1 = createJob$2;
-const { log: log$1 } = log$2;
-const getId$1 = getId$3;
-let schedulerCounter = 0;
-var createScheduler$1 = () => {
-  const id = getId$1("Scheduler", schedulerCounter);
-  const workers = {};
-  const runningWorkers = {};
-  let jobQueue = [];
-  schedulerCounter += 1;
-  const getQueueLen = () => jobQueue.length;
-  const getNumWorkers = () => Object.keys(workers).length;
-  const dequeue = () => {
-    if (jobQueue.length !== 0) {
-      const wIds = Object.keys(workers);
-      for (let i = 0; i < wIds.length; i += 1) {
-        if (typeof runningWorkers[wIds[i]] === "undefined") {
-          jobQueue[0](workers[wIds[i]]);
-          break;
-        }
-      }
+    payload = {}
+  }) => {
+    let id = _id;
+    if (typeof id === "undefined") {
+      id = getId2("Job", jobCounter);
+      jobCounter += 1;
     }
+    return {
+      id,
+      action,
+      payload
+    };
   };
-  const queue = (action, payload) => new Promise((resolve, reject) => {
-    const job = createJob$1({ action, payload });
-    jobQueue.push(async (w) => {
-      jobQueue.shift();
-      runningWorkers[w.id] = job;
-      try {
-        resolve(await w[action].apply(void 0, [...payload, job.id]));
-      } catch (err) {
-        reject(err);
-      } finally {
-        delete runningWorkers[w.id];
-        dequeue();
+  return createJob;
+}
+var log = {};
+var hasRequiredLog;
+function requireLog() {
+  if (hasRequiredLog) return log;
+  hasRequiredLog = 1;
+  let logging = false;
+  log.logging = logging;
+  log.setLogging = (_logging) => {
+    logging = _logging;
+  };
+  log.log = (...args) => logging ? console.log.apply(this, args) : null;
+  return log;
+}
+var createScheduler;
+var hasRequiredCreateScheduler;
+function requireCreateScheduler() {
+  if (hasRequiredCreateScheduler) return createScheduler;
+  hasRequiredCreateScheduler = 1;
+  const createJob2 = requireCreateJob();
+  const { log: log2 } = requireLog();
+  const getId2 = requireGetId();
+  let schedulerCounter = 0;
+  createScheduler = () => {
+    const id = getId2("Scheduler", schedulerCounter);
+    const workers = {};
+    const runningWorkers = {};
+    let jobQueue = [];
+    schedulerCounter += 1;
+    const getQueueLen = () => jobQueue.length;
+    const getNumWorkers = () => Object.keys(workers).length;
+    const dequeue = () => {
+      if (jobQueue.length !== 0) {
+        const wIds = Object.keys(workers);
+        for (let i = 0; i < wIds.length; i += 1) {
+          if (typeof runningWorkers[wIds[i]] === "undefined") {
+            jobQueue[0](workers[wIds[i]]);
+            break;
+          }
+        }
       }
+    };
+    const queue = (action, payload) => new Promise((resolve, reject) => {
+      const job = createJob2({ action, payload });
+      jobQueue.push(async (w) => {
+        jobQueue.shift();
+        runningWorkers[w.id] = job;
+        try {
+          resolve(await w[action].apply(this, [...payload, job.id]));
+        } catch (err) {
+          reject(err);
+        } finally {
+          delete runningWorkers[w.id];
+          dequeue();
+        }
+      });
+      log2(`[${id}]: Add ${job.id} to JobQueue`);
+      log2(`[${id}]: JobQueue length=${jobQueue.length}`);
+      dequeue();
     });
-    log$1(`[${id}]: Add ${job.id} to JobQueue`);
-    log$1(`[${id}]: JobQueue length=${jobQueue.length}`);
-    dequeue();
-  });
-  const addWorker = (w) => {
-    workers[w.id] = w;
-    log$1(`[${id}]: Add ${w.id}`);
-    log$1(`[${id}]: Number of workers=${getNumWorkers()}`);
-    dequeue();
-    return w.id;
+    const addWorker = (w) => {
+      workers[w.id] = w;
+      log2(`[${id}]: Add ${w.id}`);
+      log2(`[${id}]: Number of workers=${getNumWorkers()}`);
+      dequeue();
+      return w.id;
+    };
+    const addJob = async (action, ...payload) => {
+      if (getNumWorkers() === 0) {
+        throw Error(`[${id}]: You need to have at least one worker before adding jobs`);
+      }
+      return queue(action, payload);
+    };
+    const terminate = async () => {
+      Object.keys(workers).forEach(async (wid) => {
+        await workers[wid].terminate();
+      });
+      jobQueue = [];
+    };
+    return {
+      addWorker,
+      addJob,
+      terminate,
+      getQueueLen,
+      getNumWorkers
+    };
   };
-  const addJob = async (action, ...payload) => {
-    if (getNumWorkers() === 0) {
-      throw Error(`[${id}]: You need to have at least one worker before adding jobs`);
+  return createScheduler;
+}
+function commonjsRequire(path) {
+  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+var getEnvironment;
+var hasRequiredGetEnvironment;
+function requireGetEnvironment() {
+  if (hasRequiredGetEnvironment) return getEnvironment;
+  hasRequiredGetEnvironment = 1;
+  getEnvironment = (key) => {
+    const env = {};
+    if (typeof WorkerGlobalScope !== "undefined") {
+      env.type = "webworker";
+    } else if (typeof document === "object") {
+      env.type = "browser";
+    } else if (typeof process === "object" && typeof commonjsRequire === "function") {
+      env.type = "node";
     }
-    return queue(action, payload);
+    if (typeof key === "undefined") {
+      return env;
+    }
+    return env[key];
   };
-  const terminate = async () => {
-    Object.keys(workers).forEach(async (wid) => {
-      await workers[wid].terminate();
+  return getEnvironment;
+}
+var resolvePaths;
+var hasRequiredResolvePaths;
+function requireResolvePaths() {
+  if (hasRequiredResolvePaths) return resolvePaths;
+  hasRequiredResolvePaths = 1;
+  const isBrowser = requireGetEnvironment()("type") === "browser";
+  const resolveURL = isBrowser ? (s) => new URL(s, window.location.href).href : (s) => s;
+  resolvePaths = (options) => {
+    const opts = { ...options };
+    ["corePath", "workerPath", "langPath"].forEach((key) => {
+      if (options[key]) {
+        opts[key] = resolveURL(opts[key]);
+      }
     });
-    jobQueue = [];
+    return opts;
   };
-  return {
-    addWorker,
-    addJob,
-    terminate,
-    getQueueLen,
-    getNumWorkers
-  };
-};
-function commonjsRequire(path) {
-  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+  return resolvePaths;
 }
-function isElectron$1() {
-  if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
-    return true;
-  }
-  if (typeof process !== "undefined" && typeof process.versions === "object" && !!process.versions.electron) {
-    return true;
-  }
-  if (typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent.indexOf("Electron") >= 0) {
-    return true;
-  }
-  return false;
+var OEM;
+var hasRequiredOEM;
+function requireOEM() {
+  if (hasRequiredOEM) return OEM;
+  hasRequiredOEM = 1;
+  OEM = {
+    TESSERACT_ONLY: 0,
+    LSTM_ONLY: 1,
+    TESSERACT_LSTM_COMBINED: 2,
+    DEFAULT: 3
+  };
+  return OEM;
 }
-var isElectron_1 = isElectron$1;
-const isElectron = isElectron_1;
-var getEnvironment = (key) => {
-  const env = {};
-  if (typeof WorkerGlobalScope !== "undefined") {
-    env.type = "webworker";
-  } else if (isElectron()) {
-    env.type = "electron";
-  } else if (typeof document === "object") {
-    env.type = "browser";
-  } else if (typeof process === "object" && typeof commonjsRequire === "function") {
-    env.type = "node";
-  }
-  if (typeof key === "undefined") {
-    return env;
-  }
-  return env[key];
+const version = "6.0.0";
+const require$$0 = {
+  version
 };
-const isBrowser = getEnvironment("type") === "browser";
-const resolveURL = isBrowser ? (s) => new URL(s, window.location.href).href : (s) => s;
-var resolvePaths$1 = (options) => {
-  const opts = { ...options };
-  ["corePath", "workerPath", "langPath"].forEach((key) => {
-    if (options[key]) {
-      opts[key] = resolveURL(opts[key]);
+var defaultOptions;
+var hasRequiredDefaultOptions$1;
+function requireDefaultOptions$1() {
+  if (hasRequiredDefaultOptions$1) return defaultOptions;
+  hasRequiredDefaultOptions$1 = 1;
+  defaultOptions = {
+    /*
+     * Use BlobURL for worker script by default
+     * TODO: remove this option
+     *
+     */
+    workerBlobURL: true,
+    logger: () => {
     }
-  });
-  return opts;
-};
-var circularize$1 = (page) => {
-  const blocks = [];
-  const paragraphs = [];
-  const lines = [];
-  const words = [];
-  const symbols = [];
-  if (page.blocks) {
-    page.blocks.forEach((block) => {
-      block.paragraphs.forEach((paragraph) => {
-        paragraph.lines.forEach((line) => {
-          line.words.forEach((word) => {
-            word.symbols.forEach((sym) => {
-              symbols.push({
-                ...sym,
-                page,
-                block,
-                paragraph,
-                line,
-                word
-              });
-            });
-            words.push({
-              ...word,
-              page,
-              block,
-              paragraph,
-              line
-            });
-          });
-          lines.push({
-            ...line,
-            page,
-            block,
-            paragraph
-          });
-        });
-        paragraphs.push({
-          ...paragraph,
-          page,
-          block
-        });
-      });
-      blocks.push({
-        ...block,
-        page
+  };
+  return defaultOptions;
+}
+var defaultOptions_1;
+var hasRequiredDefaultOptions;
+function requireDefaultOptions() {
+  if (hasRequiredDefaultOptions) return defaultOptions_1;
+  hasRequiredDefaultOptions = 1;
+  const version2 = require$$0.version;
+  const defaultOptions2 = requireDefaultOptions$1();
+  defaultOptions_1 = {
+    ...defaultOptions2,
+    workerPath: `https://cdn.jsdelivr.net/npm/tesseract.js@v${version2}/dist/worker.min.js`
+  };
+  return defaultOptions_1;
+}
+var spawnWorker;
+var hasRequiredSpawnWorker;
+function requireSpawnWorker() {
+  if (hasRequiredSpawnWorker) return spawnWorker;
+  hasRequiredSpawnWorker = 1;
+  spawnWorker = ({ workerPath, workerBlobURL }) => {
+    let worker;
+    if (Blob && URL && workerBlobURL) {
+      const blob = new Blob([`importScripts("${workerPath}");`], {
+        type: "application/javascript"
       });
-    });
-  }
-  return {
-    ...page,
-    blocks,
-    paragraphs,
-    lines,
-    words,
-    symbols
+      worker = new Worker(URL.createObjectURL(blob));
+    } else {
+      worker = new Worker(workerPath);
+    }
+    return worker;
   };
-};
-var OEM$2 = {
-  TESSERACT_ONLY: 0,
-  LSTM_ONLY: 1,
-  TESSERACT_LSTM_COMBINED: 2,
-  DEFAULT: 3
-};
-const name = "tesseract.js";
-const version$1 = "5.1.0";
-const description = "Pure Javascript Multilingual OCR";
-const main = "src/index.js";
-const types = "src/index.d.ts";
-const unpkg = "dist/tesseract.min.js";
-const jsdelivr = "dist/tesseract.min.js";
-const scripts = {
-  start: "node scripts/server.js",
-  build: "rimraf dist && webpack --config scripts/webpack.config.prod.js && rollup -c scripts/rollup.esm.mjs",
-  "profile:tesseract": "webpack-bundle-analyzer dist/tesseract-stats.json",
-  "profile:worker": "webpack-bundle-analyzer dist/worker-stats.json",
-  prepublishOnly: "npm run build",
-  wait: "rimraf dist && wait-on http://localhost:3000/dist/tesseract.min.js",
-  test: "npm-run-all -p -r start test:all",
-  "test:all": "npm-run-all wait test:browser:* test:node:all",
-  "test:node": "nyc mocha --exit --bail --require ./scripts/test-helper.js",
-  "test:node:all": "npm run test:node -- ./tests/*.test.js",
-  "test:browser-tpl": "mocha-headless-chrome -a incognito -a no-sandbox -a disable-setuid-sandbox -a disable-logging -t 300000",
-  "test:browser:detect": "npm run test:browser-tpl -- -f ./tests/detect.test.html",
-  "test:browser:recognize": "npm run test:browser-tpl -- -f ./tests/recognize.test.html",
-  "test:browser:scheduler": "npm run test:browser-tpl -- -f ./tests/scheduler.test.html",
-  "test:browser:FS": "npm run test:browser-tpl -- -f ./tests/FS.test.html",
-  lint: "eslint src",
-  "lint:fix": "eslint --fix src",
-  postinstall: "opencollective-postinstall || true"
-};
-const browser$1 = {
-  "./src/worker/node/index.js": "./src/worker/browser/index.js"
-};
-const author = "";
-const contributors = [
-  "jeromewu"
-];
-const license = "Apache-2.0";
-const devDependencies = {
-  "@babel/core": "^7.21.4",
-  "@babel/eslint-parser": "^7.21.3",
-  "@babel/preset-env": "^7.21.4",
-  "@rollup/plugin-commonjs": "^24.1.0",
-  acorn: "^8.8.2",
-  "babel-loader": "^9.1.2",
-  buffer: "^6.0.3",
-  cors: "^2.8.5",
-  eslint: "^7.32.0",
-  "eslint-config-airbnb-base": "^14.2.1",
-  "eslint-plugin-import": "^2.27.5",
-  "expect.js": "^0.3.1",
-  express: "^4.18.2",
-  mocha: "^10.2.0",
-  "mocha-headless-chrome": "^4.0.0",
-  "npm-run-all": "^4.1.5",
-  nyc: "^15.1.0",
-  rimraf: "^5.0.0",
-  rollup: "^3.20.7",
-  "wait-on": "^7.0.1",
-  webpack: "^5.79.0",
-  "webpack-bundle-analyzer": "^4.8.0",
-  "webpack-cli": "^5.0.1",
-  "webpack-dev-middleware": "^6.0.2",
-  "rollup-plugin-sourcemaps": "^0.6.3"
-};
-const dependencies = {
-  "bmp-js": "^0.1.0",
-  "idb-keyval": "^6.2.0",
-  "is-electron": "^2.2.2",
-  "is-url": "^1.2.4",
-  "node-fetch": "^2.6.9",
-  "opencollective-postinstall": "^2.0.3",
-  "regenerator-runtime": "^0.13.3",
-  "tesseract.js-core": "^5.1.0",
-  "wasm-feature-detect": "^1.2.11",
-  zlibjs: "^0.3.1"
-};
-const overrides = {
-  "@rollup/pluginutils": "^5.0.2"
-};
-const repository = {
-  type: "git",
-  url: "https://github.com/naptha/tesseract.js.git"
-};
-const bugs = {
-  url: "https://github.com/naptha/tesseract.js/issues"
-};
-const homepage = "https://github.com/naptha/tesseract.js";
-const collective = {
-  type: "opencollective",
-  url: "https://opencollective.com/tesseractjs"
-};
-const require$$0 = {
-  name,
-  version: version$1,
-  description,
-  main,
-  types,
-  unpkg,
-  jsdelivr,
-  scripts,
-  browser: browser$1,
-  author,
-  contributors,
-  license,
-  devDependencies,
-  dependencies,
-  overrides,
-  repository,
-  bugs,
-  homepage,
-  collective
-};
-var defaultOptions$3 = {
-  /*
-   * Use BlobURL for worker script by default
-   * TODO: remove this option
-   *
-   */
-  workerBlobURL: true,
-  logger: () => {
-  }
-};
-const version = require$$0.version;
-const defaultOptions$2 = defaultOptions$3;
-var defaultOptions_1 = {
-  ...defaultOptions$2,
-  workerPath: `https://cdn.jsdelivr.net/npm/tesseract.js@v${version}/dist/worker.min.js`
-};
-var spawnWorker$2 = ({ workerPath, workerBlobURL }) => {
-  let worker;
-  if (Blob && URL && workerBlobURL) {
-    const blob = new Blob([`importScripts("${workerPath}");`], {
-      type: "application/javascript"
-    });
-    worker = new Worker(URL.createObjectURL(blob));
-  } else {
-    worker = new Worker(workerPath);
-  }
-  return worker;
-};
-var terminateWorker$2 = (worker) => {
-  worker.terminate();
-};
-var onMessage$2 = (worker, handler) => {
-  worker.onmessage = ({ data }) => {
-    handler(data);
+  return spawnWorker;
+}
+var terminateWorker;
+var hasRequiredTerminateWorker;
+function requireTerminateWorker() {
+  if (hasRequiredTerminateWorker) return terminateWorker;
+  hasRequiredTerminateWorker = 1;
+  terminateWorker = (worker) => {
+    worker.terminate();
   };
-};
-var send$2 = async (worker, packet) => {
-  worker.postMessage(packet);
-};
-const readFromBlobOrFile = (blob) => new Promise((resolve, reject) => {
-  const fileReader = new FileReader();
-  fileReader.onload = () => {
-    resolve(fileReader.result);
+  return terminateWorker;
+}
+var onMessage;
+var hasRequiredOnMessage;
+function requireOnMessage() {
+  if (hasRequiredOnMessage) return onMessage;
+  hasRequiredOnMessage = 1;
+  onMessage = (worker, handler) => {
+    worker.onmessage = ({ data }) => {
+      handler(data);
+    };
   };
-  fileReader.onerror = ({ target: { error: { code } } }) => {
-    reject(Error(`File could not be read! Code=${code}`));
+  return onMessage;
+}
+var send;
+var hasRequiredSend;
+function requireSend() {
+  if (hasRequiredSend) return send;
+  hasRequiredSend = 1;
+  send = async (worker, packet) => {
+    worker.postMessage(packet);
   };
-  fileReader.readAsArrayBuffer(blob);
-});
-const loadImage$2 = async (image) => {
-  let data = image;
-  if (typeof image === "undefined") {
-    return "undefined";
-  }
-  if (typeof image === "string") {
-    if (/data:image\/([a-zA-Z]*);base64,([^"]*)/.test(image)) {
-      data = atob(image.split(",")[1]).split("").map((c) => c.charCodeAt(0));
-    } else {
-      const resp = await fetch(image);
-      data = await resp.arrayBuffer();
-    }
-  } else if (typeof HTMLElement !== "undefined" && image instanceof HTMLElement) {
-    if (image.tagName === "IMG") {
-      data = await loadImage$2(image.src);
-    }
-    if (image.tagName === "VIDEO") {
-      data = await loadImage$2(image.poster);
+  return send;
+}
+var loadImage_1;
+var hasRequiredLoadImage;
+function requireLoadImage() {
+  if (hasRequiredLoadImage) return loadImage_1;
+  hasRequiredLoadImage = 1;
+  const readFromBlobOrFile = (blob) => new Promise((resolve, reject) => {
+    const fileReader = new FileReader();
+    fileReader.onload = () => {
+      resolve(fileReader.result);
+    };
+    fileReader.onerror = ({ target: { error: { code } } }) => {
+      reject(Error(`File could not be read! Code=${code}`));
+    };
+    fileReader.readAsArrayBuffer(blob);
+  });
+  const loadImage = async (image) => {
+    let data = image;
+    if (typeof image === "undefined") {
+      return "undefined";
     }
-    if (image.tagName === "CANVAS") {
-      await new Promise((resolve) => {
-        image.toBlob(async (blob) => {
-          data = await readFromBlobOrFile(blob);
-          resolve();
+    if (typeof image === "string") {
+      if (/data:image\/([a-zA-Z]*);base64,([^"]*)/.test(image)) {
+        data = atob(image.split(",")[1]).split("").map((c) => c.charCodeAt(0));
+      } else {
+        const resp = await fetch(image);
+        data = await resp.arrayBuffer();
+      }
+    } else if (typeof HTMLElement !== "undefined" && image instanceof HTMLElement) {
+      if (image.tagName === "IMG") {
+        data = await loadImage(image.src);
+      }
+      if (image.tagName === "VIDEO") {
+        data = await loadImage(image.poster);
+      }
+      if (image.tagName === "CANVAS") {
+        await new Promise((resolve) => {
+          image.toBlob(async (blob) => {
+            data = await readFromBlobOrFile(blob);
+            resolve();
+          });
         });
-      });
+      }
+    } else if (typeof OffscreenCanvas !== "undefined" && image instanceof OffscreenCanvas) {
+      const blob = await image.convertToBlob();
+      data = await readFromBlobOrFile(blob);
+    } else if (image instanceof File || image instanceof Blob) {
+      data = await readFromBlobOrFile(image);
     }
-  } else if (typeof OffscreenCanvas !== "undefined" && image instanceof OffscreenCanvas) {
-    const blob = await image.convertToBlob();
-    data = await readFromBlobOrFile(blob);
-  } else if (image instanceof File || image instanceof Blob) {
-    data = await readFromBlobOrFile(image);
-  }
-  return new Uint8Array(data);
-};
-var loadImage_1 = loadImage$2;
-const defaultOptions$1 = defaultOptions_1;
-const spawnWorker$1 = spawnWorker$2;
-const terminateWorker$1 = terminateWorker$2;
-const onMessage$1 = onMessage$2;
-const send$1 = send$2;
-const loadImage$1 = loadImage_1;
-var browser = {
-  defaultOptions: defaultOptions$1,
-  spawnWorker: spawnWorker$1,
-  terminateWorker: terminateWorker$1,
-  onMessage: onMessage$1,
-  send: send$1,
-  loadImage: loadImage$1
-};
-const resolvePaths = resolvePaths$1;
-const circularize = circularize$1;
-const createJob = createJob$2;
-const { log } = log$2;
-const getId = getId$3;
-const OEM$1 = OEM$2;
-const {
-  defaultOptions,
-  spawnWorker,
-  terminateWorker,
-  onMessage,
-  loadImage,
-  send
-} = browser;
-let workerCounter = 0;
-var createWorker$2 = async (langs = "eng", oem = OEM$1.LSTM_ONLY, _options = {}, config = {}) => {
-  const id = getId("Worker", workerCounter);
-  const {
-    logger,
-    errorHandler,
-    ...options
-  } = resolvePaths({
-    ...defaultOptions,
-    ..._options
-  });
-  const resolves = {};
-  const rejects = {};
-  const currentLangs = typeof langs === "string" ? langs.split("+") : langs;
-  let currentOem = oem;
-  let currentConfig = config;
-  const lstmOnlyCore = [OEM$1.DEFAULT, OEM$1.LSTM_ONLY].includes(oem) && !options.legacyCore;
-  let workerResReject;
-  let workerResResolve;
-  const workerRes = new Promise((resolve, reject) => {
-    workerResResolve = resolve;
-    workerResReject = reject;
-  });
-  const workerError = (event) => {
-    workerResReject(event.message);
-  };
-  let worker = spawnWorker(options);
-  worker.onerror = workerError;
-  workerCounter += 1;
-  const setResolve = (promiseId, res) => {
-    resolves[promiseId] = res;
+    return new Uint8Array(data);
   };
-  const setReject = (promiseId, rej) => {
-    rejects[promiseId] = rej;
+  loadImage_1 = loadImage;
+  return loadImage_1;
+}
+var browser;
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser;
+  hasRequiredBrowser = 1;
+  const defaultOptions2 = requireDefaultOptions();
+  const spawnWorker2 = requireSpawnWorker();
+  const terminateWorker2 = requireTerminateWorker();
+  const onMessage2 = requireOnMessage();
+  const send2 = requireSend();
+  const loadImage = requireLoadImage();
+  browser = {
+    defaultOptions: defaultOptions2,
+    spawnWorker: spawnWorker2,
+    terminateWorker: terminateWorker2,
+    onMessage: onMessage2,
+    send: send2,
+    loadImage
   };
-  const startJob = ({ id: jobId, action, payload }) => new Promise((resolve, reject) => {
-    log(`[${id}]: Start ${jobId}, action=${action}`);
-    const promiseId = `${action}-${jobId}`;
-    setResolve(promiseId, resolve);
-    setReject(promiseId, reject);
-    send(worker, {
-      workerId: id,
-      jobId,
-      action,
-      payload
+  return browser;
+}
+var createWorker;
+var hasRequiredCreateWorker;
+function requireCreateWorker() {
+  if (hasRequiredCreateWorker) return createWorker;
+  hasRequiredCreateWorker = 1;
+  const resolvePaths2 = requireResolvePaths();
+  const createJob2 = requireCreateJob();
+  const { log: log2 } = requireLog();
+  const getId2 = requireGetId();
+  const OEM2 = requireOEM();
+  const {
+    defaultOptions: defaultOptions2,
+    spawnWorker: spawnWorker2,
+    terminateWorker: terminateWorker2,
+    onMessage: onMessage2,
+    loadImage,
+    send: send2
+  } = requireBrowser();
+  let workerCounter = 0;
+  createWorker = async (langs = "eng", oem = OEM2.LSTM_ONLY, _options = {}, config = {}) => {
+    const id = getId2("Worker", workerCounter);
+    const {
+      logger,
+      errorHandler,
+      ...options
+    } = resolvePaths2({
+      ...defaultOptions2,
+      ..._options
     });
-  });
-  const load = () => console.warn("`load` is depreciated and should be removed from code (workers now come pre-loaded)");
-  const loadInternal = (jobId) => startJob(createJob({
-    id: jobId,
-    action: "load",
-    payload: { options: { lstmOnly: lstmOnlyCore, corePath: options.corePath, logging: options.logging } }
-  }));
-  const writeText = (path, text, jobId) => startJob(createJob({
-    id: jobId,
-    action: "FS",
-    payload: { method: "writeFile", args: [path, text] }
-  }));
-  const readText = (path, jobId) => startJob(createJob({
-    id: jobId,
-    action: "FS",
-    payload: { method: "readFile", args: [path, { encoding: "utf8" }] }
-  }));
-  const removeFile = (path, jobId) => startJob(createJob({
-    id: jobId,
-    action: "FS",
-    payload: { method: "unlink", args: [path] }
-  }));
-  const FS = (method, args, jobId) => startJob(createJob({
-    id: jobId,
-    action: "FS",
-    payload: { method, args }
-  }));
-  const loadLanguage = () => console.warn("`loadLanguage` is depreciated and should be removed from code (workers now come with language pre-loaded)");
-  const loadLanguageInternal = (_langs, jobId) => startJob(createJob({
-    id: jobId,
-    action: "loadLanguage",
-    payload: {
-      langs: _langs,
-      options: {
-        langPath: options.langPath,
-        dataPath: options.dataPath,
-        cachePath: options.cachePath,
-        cacheMethod: options.cacheMethod,
-        gzip: options.gzip,
-        lstmOnly: [OEM$1.LSTM_ONLY, OEM$1.TESSERACT_LSTM_COMBINED].includes(currentOem) && !options.legacyLang
+    const promises = {};
+    const currentLangs = typeof langs === "string" ? langs.split("+") : langs;
+    let currentOem = oem;
+    let currentConfig = config;
+    const lstmOnlyCore = [OEM2.DEFAULT, OEM2.LSTM_ONLY].includes(oem) && !options.legacyCore;
+    let workerResReject;
+    let workerResResolve;
+    const workerRes = new Promise((resolve, reject) => {
+      workerResResolve = resolve;
+      workerResReject = reject;
+    });
+    const workerError = (event) => {
+      workerResReject(event.message);
+    };
+    let worker = spawnWorker2(options);
+    worker.onerror = workerError;
+    workerCounter += 1;
+    const startJob = ({ id: jobId, action, payload }) => new Promise((resolve, reject) => {
+      log2(`[${id}]: Start ${jobId}, action=${action}`);
+      const promiseId = `${action}-${jobId}`;
+      promises[promiseId] = { resolve, reject };
+      send2(worker, {
+        workerId: id,
+        jobId,
+        action,
+        payload
+      });
+    });
+    const load = () => console.warn("`load` is depreciated and should be removed from code (workers now come pre-loaded)");
+    const loadInternal = (jobId) => startJob(createJob2({
+      id: jobId,
+      action: "load",
+      payload: { options: { lstmOnly: lstmOnlyCore, corePath: options.corePath, logging: options.logging } }
+    }));
+    const writeText = (path, text, jobId) => startJob(createJob2({
+      id: jobId,
+      action: "FS",
+      payload: { method: "writeFile", args: [path, text] }
+    }));
+    const readText = (path, jobId) => startJob(createJob2({
+      id: jobId,
+      action: "FS",
+      payload: { method: "readFile", args: [path, { encoding: "utf8" }] }
+    }));
+    const removeFile = (path, jobId) => startJob(createJob2({
+      id: jobId,
+      action: "FS",
+      payload: { method: "unlink", args: [path] }
+    }));
+    const FS = (method, args, jobId) => startJob(createJob2({
+      id: jobId,
+      action: "FS",
+      payload: { method, args }
+    }));
+    const loadLanguageInternal = (_langs, jobId) => startJob(createJob2({
+      id: jobId,
+      action: "loadLanguage",
+      payload: {
+        langs: _langs,
+        options: {
+          langPath: options.langPath,
+          dataPath: options.dataPath,
+          cachePath: options.cachePath,
+          cacheMethod: options.cacheMethod,
+          gzip: options.gzip,
+          lstmOnly: [OEM2.DEFAULT, OEM2.LSTM_ONLY].includes(currentOem) && !options.legacyLang
+        }
       }
-    }
-  }));
-  const initialize = () => console.warn("`initialize` is depreciated and should be removed from code (workers now come pre-initialized)");
-  const initializeInternal = (_langs, _oem, _config, jobId) => startJob(createJob({
-    id: jobId,
-    action: "initialize",
-    payload: { langs: _langs, oem: _oem, config: _config }
-  }));
-  const reinitialize = (langs2 = "eng", oem2, config2, jobId) => {
-    if (lstmOnlyCore && [OEM$1.TESSERACT_ONLY, OEM$1.TESSERACT_LSTM_COMBINED].includes(oem2)) throw Error("Legacy model requested but code missing.");
-    const _oem = oem2 || currentOem;
-    currentOem = _oem;
-    const _config = config2 || currentConfig;
-    currentConfig = _config;
-    const langsArr = typeof langs2 === "string" ? langs2.split("+") : langs2;
-    const _langs = langsArr.filter((x) => !currentLangs.includes(x));
-    currentLangs.push(..._langs);
-    if (_langs.length > 0) {
-      return loadLanguageInternal(_langs, jobId).then(() => initializeInternal(langs2, _oem, _config, jobId));
-    }
-    return initializeInternal(langs2, _oem, _config, jobId);
-  };
-  const setParameters = (params = {}, jobId) => startJob(createJob({
-    id: jobId,
-    action: "setParameters",
-    payload: { params }
-  }));
-  const recognize2 = async (image, opts = {}, output = {
-    blocks: true,
-    text: true,
-    hocr: true,
-    tsv: true
-  }, jobId) => startJob(createJob({
-    id: jobId,
-    action: "recognize",
-    payload: { image: await loadImage(image), options: opts, output }
-  }));
-  const getPDF = (title = "Tesseract OCR Result", textonly = false, jobId) => {
-    return startJob(createJob({
+    }));
+    const initializeInternal = (_langs, _oem, _config, jobId) => startJob(createJob2({
       id: jobId,
-      action: "getPDF",
-      payload: { title, textonly }
+      action: "initialize",
+      payload: { langs: _langs, oem: _oem, config: _config }
     }));
-  };
-  const detect2 = async (image, jobId) => {
-    if (lstmOnlyCore) throw Error("`worker.detect` requires Legacy model, which was not loaded.");
-    return startJob(createJob({
+    const reinitialize = (langs2 = "eng", oem2, config2, jobId) => {
+      if (lstmOnlyCore && [OEM2.TESSERACT_ONLY, OEM2.TESSERACT_LSTM_COMBINED].includes(oem2)) throw Error("Legacy model requested but code missing.");
+      const _oem = oem2 || currentOem;
+      currentOem = _oem;
+      const _config = config2 || currentConfig;
+      currentConfig = _config;
+      const langsArr = typeof langs2 === "string" ? langs2.split("+") : langs2;
+      const _langs = langsArr.filter((x) => !currentLangs.includes(x));
+      currentLangs.push(..._langs);
+      if (_langs.length > 0) {
+        return loadLanguageInternal(_langs, jobId).then(() => initializeInternal(langs2, _oem, _config, jobId));
+      }
+      return initializeInternal(langs2, _oem, _config, jobId);
+    };
+    const setParameters = (params = {}, jobId) => startJob(createJob2({
       id: jobId,
-      action: "detect",
-      payload: { image: await loadImage(image) }
+      action: "setParameters",
+      payload: { params }
     }));
-  };
-  const terminate = async () => {
-    if (worker !== null) {
-      terminateWorker(worker);
-      worker = null;
-    }
-    return Promise.resolve();
-  };
-  onMessage(worker, ({
-    workerId,
-    jobId,
-    status,
-    action,
-    data
-  }) => {
-    const promiseId = `${action}-${jobId}`;
-    if (status === "resolve") {
-      log(`[${workerId}]: Complete ${jobId}`);
-      let d = data;
-      if (action === "recognize") {
-        d = circularize(data);
-      } else if (action === "getPDF") {
-        d = Array.from({ ...data, length: Object.keys(data).length });
+    const recognize = async (image, opts = {}, output = {
+      text: true
+    }, jobId) => startJob(createJob2({
+      id: jobId,
+      action: "recognize",
+      payload: { image: await loadImage(image), options: opts, output }
+    }));
+    const detect = async (image, jobId) => {
+      if (lstmOnlyCore) throw Error("`worker.detect` requires Legacy model, which was not loaded.");
+      return startJob(createJob2({
+        id: jobId,
+        action: "detect",
+        payload: { image: await loadImage(image) }
+      }));
+    };
+    const terminate = async () => {
+      if (worker !== null) {
+        terminateWorker2(worker);
+        worker = null;
       }
-      resolves[promiseId]({ jobId, data: d });
-    } else if (status === "reject") {
-      rejects[promiseId](data);
-      if (action === "load") workerResReject(data);
-      if (errorHandler) {
-        errorHandler(data);
-      } else {
-        throw Error(data);
+      return Promise.resolve();
+    };
+    onMessage2(worker, ({
+      workerId,
+      jobId,
+      status,
+      action,
+      data
+    }) => {
+      const promiseId = `${action}-${jobId}`;
+      if (status === "resolve") {
+        log2(`[${workerId}]: Complete ${jobId}`);
+        promises[promiseId].resolve({ jobId, data });
+        delete promises[promiseId];
+      } else if (status === "reject") {
+        promises[promiseId].reject(data);
+        delete promises[promiseId];
+        if (action === "load") workerResReject(data);
+        if (errorHandler) {
+          errorHandler(data);
+        } else {
+          throw Error(data);
+        }
+      } else if (status === "progress") {
+        logger({ ...data, userJobId: jobId });
       }
-    } else if (status === "progress") {
-      logger({ ...data, userJobId: jobId });
-    }
-  });
-  const resolveObj = {
-    id,
-    worker,
-    setResolve,
-    setReject,
-    load,
-    writeText,
-    readText,
-    removeFile,
-    FS,
-    loadLanguage,
-    initialize,
-    reinitialize,
-    setParameters,
-    recognize: recognize2,
-    getPDF,
-    detect: detect2,
-    terminate
+    });
+    const resolveObj = {
+      id,
+      worker,
+      load,
+      writeText,
+      readText,
+      removeFile,
+      FS,
+      reinitialize,
+      setParameters,
+      recognize,
+      detect,
+      terminate
+    };
+    loadInternal().then(() => loadLanguageInternal(langs)).then(() => initializeInternal(langs, oem, config)).then(() => workerResResolve(resolveObj)).catch(() => {
+    });
+    return workerRes;
   };
-  loadInternal().then(() => loadLanguageInternal(langs)).then(() => initializeInternal(langs, oem, config)).then(() => workerResResolve(resolveObj)).catch(() => {
-  });
-  return workerRes;
-};
-const createWorker$1 = createWorker$2;
-const recognize = async (image, langs, options) => {
-  const worker = await createWorker$1(langs, 1, options);
-  return worker.recognize(image).finally(async () => {
-    await worker.terminate();
-  });
-};
-const detect = async (image, options) => {
-  const worker = await createWorker$1("osd", 0, options);
-  return worker.detect(image).finally(async () => {
-    await worker.terminate();
-  });
-};
-var Tesseract$1 = {
-  recognize,
-  detect
-};
-var languages$1 = {
-  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"
-};
-var PSM$1 = {
-  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"
-};
-const createScheduler = createScheduler$1;
-const createWorker = createWorker$2;
-const Tesseract = Tesseract$1;
-const languages = languages$1;
-const OEM = OEM$2;
-const PSM = PSM$1;
-const { setLogging } = log$2;
-var src = {
-  languages,
-  OEM,
-  PSM,
-  createScheduler,
-  createWorker,
-  setLogging,
-  ...Tesseract
-};
+  return createWorker;
+}
+var Tesseract;
+var hasRequiredTesseract;
+function requireTesseract() {
+  if (hasRequiredTesseract) return Tesseract;
+  hasRequiredTesseract = 1;
+  const createWorker2 = requireCreateWorker();
+  const recognize = async (image, langs, options) => {
+    const worker = await createWorker2(langs, 1, options);
+    return worker.recognize(image).finally(async () => {
+      await worker.terminate();
+    });
+  };
+  const detect = async (image, options) => {
+    const worker = await createWorker2("osd", 0, options);
+    return worker.detect(image).finally(async () => {
+      await worker.terminate();
+    });
+  };
+  Tesseract = {
+    recognize,
+    detect
+  };
+  return Tesseract;
+}
+var languages;
+var hasRequiredLanguages;
+function requireLanguages() {
+  if (hasRequiredLanguages) return languages;
+  hasRequiredLanguages = 1;
+  languages = {
+    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"
+  };
+  return languages;
+}
+var PSM;
+var hasRequiredPSM;
+function requirePSM() {
+  if (hasRequiredPSM) return PSM;
+  hasRequiredPSM = 1;
+  PSM = {
+    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"
+  };
+  return PSM;
+}
+var src;
+var hasRequiredSrc;
+function requireSrc() {
+  if (hasRequiredSrc) return src;
+  hasRequiredSrc = 1;
+  requireRuntime();
+  const createScheduler2 = requireCreateScheduler();
+  const createWorker2 = requireCreateWorker();
+  const Tesseract2 = requireTesseract();
+  const languages2 = requireLanguages();
+  const OEM2 = requireOEM();
+  const PSM2 = requirePSM();
+  const { setLogging } = requireLog();
+  src = {
+    languages: languages2,
+    OEM: OEM2,
+    PSM: PSM2,
+    createScheduler: createScheduler2,
+    createWorker: createWorker2,
+    setLogging,
+    ...Tesseract2
+  };
+  return src;
+}
+var srcExports = requireSrc();
 const ocr = async ({ images = [], language = "eng", langPath = "" }) => {
   if (images.length === 0) return { success: false, data: null, message: "images must be a array" };
   if (!language) return { success: false, data: null, message: "languages must be a array" };
@@ -1293,8 +1231,8 @@ const ocr = async ({ images = [], language = "eng", langPath = "" }) => {
   if (langPath) {
     options = { langPath };
   }
-  const scheduler = src.createScheduler();
-  const worker = await src.createWorker(language, 3, options);
+  const scheduler = srcExports.createScheduler();
+  const worker = await srcExports.createWorker(language, 3, options);
   scheduler.addWorker(worker);
   const results = await Promise.all(images.map((image) => scheduler.addJob("recognize", image)));
   await scheduler.terminate();