@jbrowse/plugin-legacy-jbrowse 1.5.1 → 1.5.2

package/dist/plugin-legacy-jbrowse.esm.js

@@ -17,6 +17,81 @@ import NCListStore from '@gmod/nclist';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import { RemoteFile } from 'generic-filehandle';
 
+function _asyncIterator(iterable) {
+  var method,
+      async,
+      sync,
+      retry = 2;
+
+  if (typeof Symbol !== "undefined") {
+    async = Symbol.asyncIterator;
+    sync = Symbol.iterator;
+  }
+
+  while (retry--) {
+    if (async && (method = iterable[async]) != null) {
+      return method.call(iterable);
+    }
+
+    if (sync && (method = iterable[sync]) != null) {
+      return new AsyncFromSyncIterator(method.call(iterable));
+    }
+
+    async = "@@asyncIterator";
+    sync = "@@iterator";
+  }
+
+  throw new TypeError("Object is not async iterable");
+}
+
+function AsyncFromSyncIterator(s) {
+  AsyncFromSyncIterator = function (s) {
+    this.s = s;
+    this.n = s.next;
+  };
+
+  AsyncFromSyncIterator.prototype = {
+    s: null,
+    n: null,
+    next: function () {
+      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+    },
+    return: function (value) {
+      var ret = this.s.return;
+
+      if (ret === undefined) {
+        return Promise.resolve({
+          value: value,
+          done: true
+        });
+      }
+
+      return AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+    },
+    throw: function (value) {
+      var thr = this.s.return;
+      if (thr === undefined) return Promise.reject(value);
+      return AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+    }
+  };
+
+  function AsyncFromSyncIteratorContinuation(r) {
+    if (Object(r) !== r) {
+      return Promise.reject(new TypeError(r + " is not an object."));
+    }
+
+    var done = r.done;
+    return Promise.resolve(r.value).then(function (value) {
+      return {
+        value: value,
+        done: done
+      };
+    });
+  }
+
+  return new AsyncFromSyncIterator(s);
+}
+
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
 
@@ -71,20 +146,6 @@ function _typeof(obj) {
   return _typeof(obj);
 }
 
-function _asyncIterator(iterable) {
-  var method;
-
-  if (typeof Symbol !== "undefined") {
-    if (Symbol.asyncIterator) method = iterable[Symbol.asyncIterator];
-    if (method == null && Symbol.iterator) method = iterable[Symbol.iterator];
-  }
-
-  if (method == null) method = iterable["@@asyncIterator"];
-  if (method == null) method = iterable["@@iterator"];
-  if (method == null) throw new TypeError("Object is not async iterable");
-  return method.call(iterable);
-}
-
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg);
@@ -1716,7 +1777,8 @@ function mixin(dest, source, copyFunc) {
     // toString() method that source inherited from Object.prototype
     s = source[name];
 
-    if (!(name in dest) || dest[name] !== s && (!(name in empty) || empty[name] !== s)) {
+    if (!(name in dest) || // @ts-ignore
+    dest[name] !== s && (!(name in empty) || empty[name] !== s)) {
       dest[name] = copyFunc ? copyFunc(s) : s;
     }
   }