@loaders.gl/worker-utils 3.1.0-beta.4 → 3.1.0

package/dist/es5/index.js

@@ -7,109 +7,109 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "assert", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _assert.assert;
   }
 });
 Object.defineProperty(exports, "isBrowser", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _globals.isBrowser;
   }
 });
 Object.defineProperty(exports, "isWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _globals.isWorker;
   }
 });
 Object.defineProperty(exports, "WorkerJob", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _workerJob.default;
   }
 });
 Object.defineProperty(exports, "WorkerThread", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _workerThread.default;
   }
 });
 Object.defineProperty(exports, "WorkerFarm", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _workerFarm.default;
   }
 });
 Object.defineProperty(exports, "WorkerPool", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _workerPool.default;
   }
 });
 Object.defineProperty(exports, "WorkerBody", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _workerBody.default;
   }
 });
 Object.defineProperty(exports, "processOnWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _processOnWorker.processOnWorker;
   }
 });
 Object.defineProperty(exports, "canProcessOnWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _processOnWorker.canProcessOnWorker;
   }
 });
 Object.defineProperty(exports, "createWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _createWorker.createWorker;
   }
 });
 Object.defineProperty(exports, "getWorkerURL", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _getWorkerUrl.getWorkerURL;
   }
 });
 Object.defineProperty(exports, "validateWorkerVersion", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _validateWorkerVersion.validateWorkerVersion;
   }
 });
 Object.defineProperty(exports, "getTransferList", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _getTransferList.getTransferList;
   }
 });
 Object.defineProperty(exports, "getLibraryUrl", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _libraryUtils.getLibraryUrl;
   }
 });
 Object.defineProperty(exports, "loadLibrary", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _libraryUtils.loadLibrary;
   }
 });
 Object.defineProperty(exports, "AsyncQueue", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _asyncQueue.default;
   }
 });
 Object.defineProperty(exports, "ChildProcessProxy", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _childProcessProxy.default;
   }
 });
@@ -147,7 +147,7 @@ var _asyncQueue = _interopRequireDefault(require("./lib/async-queue/async-queue"
 
 var _childProcessProxy = _interopRequireDefault(require("./lib/process-utils/child-process-proxy"));
 
-const NullWorker = {
+var NullWorker = {
   id: 'null',
   name: 'null',
   module: 'worker-utils',

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":["NullWorker","id","name","module","version","VERSION","options","null"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAcA;;AACA;;AAGA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AAGA;;AAGA;;AAKO,MAAMA,UAAwB,GAAG;AACtCC,EAAAA,EAAE,EAAE,MADkC;AAEtCC,EAAAA,IAAI,EAAE,MAFgC;AAGtCC,EAAAA,MAAM,EAAE,cAH8B;AAItCC,EAAAA,OAAO,EAAEC,gBAJ6B;AAKtCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAL6B,CAAjC","sourcesContent":["import type {WorkerObject} from './types';\nimport {VERSION} from './lib/env-utils/version';\n\n// TYPES\nexport type {\n  WorkerObject,\n  WorkerOptions,\n  // Protocol\n  WorkerMessage,\n  WorkerMessageType,\n  WorkerMessageData,\n  WorkerMessagePayload\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {isBrowser, isWorker} from './lib/env-utils/globals';\n\n// WORKER UTILS - TYPES\nexport {default as WorkerJob} from './lib/worker-farm/worker-job';\nexport {default as WorkerThread} from './lib/worker-farm/worker-thread';\n\n// WORKER FARMS\nexport {default as WorkerFarm} from './lib/worker-farm/worker-farm';\nexport {default as WorkerPool} from './lib/worker-farm/worker-pool';\nexport {default as WorkerBody} from './lib/worker-farm/worker-body';\n\nexport {processOnWorker, canProcessOnWorker} from './lib/worker-api/process-on-worker';\nexport {createWorker} from './lib/worker-api/create-worker';\n\n// WORKER UTILS - EXPORTS\nexport {getWorkerURL} from './lib/worker-api/get-worker-url';\nexport {validateWorkerVersion} from './lib/worker-api/validate-worker-version';\nexport {getTransferList} from './lib/worker-utils/get-transfer-list';\n\n// LIBRARY UTILS\nexport {getLibraryUrl, loadLibrary} from './lib/library-utils/library-utils';\n\n// PARSER UTILS\nexport {default as AsyncQueue} from './lib/async-queue/async-queue';\n\n// PROCESS UTILS\nexport {default as ChildProcessProxy} from './lib/process-utils/child-process-proxy';\n\n// WORKER OBJECTS\n\n/** A null worker to test that worker processing is functional */\nexport const NullWorker: WorkerObject = {\n  id: 'null',\n  name: 'null',\n  module: 'worker-utils',\n  version: VERSION,\n  options: {\n    null: {}\n  }\n};\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":["NullWorker","id","name","module","version","VERSION","options","null"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAcA;;AACA;;AAGA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AAGA;;AAGA;;AAKO,IAAMA,UAAwB,GAAG;AACtCC,EAAAA,EAAE,EAAE,MADkC;AAEtCC,EAAAA,IAAI,EAAE,MAFgC;AAGtCC,EAAAA,MAAM,EAAE,cAH8B;AAItCC,EAAAA,OAAO,EAAEC,gBAJ6B;AAKtCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAL6B,CAAjC","sourcesContent":["import type {WorkerObject} from './types';\nimport {VERSION} from './lib/env-utils/version';\n\n// TYPES\nexport type {\n  WorkerObject,\n  WorkerOptions,\n  // Protocol\n  WorkerMessage,\n  WorkerMessageType,\n  WorkerMessageData,\n  WorkerMessagePayload\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {isBrowser, isWorker} from './lib/env-utils/globals';\n\n// WORKER UTILS - TYPES\nexport {default as WorkerJob} from './lib/worker-farm/worker-job';\nexport {default as WorkerThread} from './lib/worker-farm/worker-thread';\n\n// WORKER FARMS\nexport {default as WorkerFarm} from './lib/worker-farm/worker-farm';\nexport {default as WorkerPool} from './lib/worker-farm/worker-pool';\nexport {default as WorkerBody} from './lib/worker-farm/worker-body';\n\nexport {processOnWorker, canProcessOnWorker} from './lib/worker-api/process-on-worker';\nexport {createWorker} from './lib/worker-api/create-worker';\n\n// WORKER UTILS - EXPORTS\nexport {getWorkerURL} from './lib/worker-api/get-worker-url';\nexport {validateWorkerVersion} from './lib/worker-api/validate-worker-version';\nexport {getTransferList} from './lib/worker-utils/get-transfer-list';\n\n// LIBRARY UTILS\nexport {getLibraryUrl, loadLibrary} from './lib/library-utils/library-utils';\n\n// PARSER UTILS\nexport {default as AsyncQueue} from './lib/async-queue/async-queue';\n\n// PROCESS UTILS\nexport {default as ChildProcessProxy} from './lib/process-utils/child-process-proxy';\n\n// WORKER OBJECTS\n\n/** A null worker to test that worker processing is functional */\nexport const NullWorker: WorkerObject = {\n  id: 'null',\n  name: 'null',\n  module: 'worker-utils',\n  version: VERSION,\n  options: {\n    null: {}\n  }\n};\n"],"file":"index.js"}

package/dist/es5/lib/async-queue/async-queue.js

@@ -7,14 +7,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-let _Symbol$asyncIterator;
+var _Symbol$asyncIterator;
 
 _Symbol$asyncIterator = Symbol.asyncIterator;
 
-class AsyncQueue {
-  constructor() {
+var AsyncQueue = function () {
+  function AsyncQueue() {
+    (0, _classCallCheck2.default)(this, AsyncQueue);
     (0, _defineProperty2.default)(this, "_values", void 0);
     (0, _defineProperty2.default)(this, "_settlers", void 0);
     (0, _defineProperty2.default)(this, "_closed", void 0);
@@ -23,84 +28,93 @@ class AsyncQueue {
     this._closed = false;
   }
 
-  [_Symbol$asyncIterator]() {
-    return this;
-  }
-
-  push(value) {
-    return this.enqueue(value);
-  }
-
-  enqueue(value) {
-    if (this._closed) {
-      throw new Error('Closed');
+  (0, _createClass2.default)(AsyncQueue, [{
+    key: _Symbol$asyncIterator,
+    value: function value() {
+      return this;
     }
-
-    if (this._settlers.length > 0) {
-      if (this._values.length > 0) {
-        throw new Error('Illegal internal state');
+  }, {
+    key: "push",
+    value: function push(value) {
+      return this.enqueue(value);
+    }
+  }, {
+    key: "enqueue",
+    value: function enqueue(value) {
+      if (this._closed) {
+        throw new Error('Closed');
       }
 
-      const settler = this._settlers.shift();
-
-      if (value instanceof Error) {
-        settler.reject(value);
+      if (this._settlers.length > 0) {
+        if (this._values.length > 0) {
+          throw new Error('Illegal internal state');
+        }
+
+        var settler = this._settlers.shift();
+
+        if (value instanceof Error) {
+          settler.reject(value);
+        } else {
+          settler.resolve({
+            value: value
+          });
+        }
       } else {
-        settler.resolve({
-          value
-        });
+        this._values.push(value);
       }
-    } else {
-      this._values.push(value);
     }
-  }
+  }, {
+    key: "close",
+    value: function close() {
+      while (this._settlers.length > 0) {
+        var settler = this._settlers.shift();
 
-  close() {
-    while (this._settlers.length > 0) {
-      const settler = this._settlers.shift();
+        settler.resolve({
+          done: true
+        });
+      }
 
-      settler.resolve({
-        done: true
-      });
+      this._closed = true;
     }
+  }, {
+    key: "next",
+    value: function next() {
+      var _this = this;
 
-    this._closed = true;
-  }
+      if (this._values.length > 0) {
+        var value = this._values.shift();
 
-  next() {
-    if (this._values.length > 0) {
-      const value = this._values.shift();
+        if (value instanceof Error) {
+          return Promise.reject(value);
+        }
 
-      if (value instanceof Error) {
-        return Promise.reject(value);
+        return Promise.resolve({
+          done: false,
+          value: value
+        });
       }
 
-      return Promise.resolve({
-        done: false,
-        value
-      });
-    }
+      if (this._closed) {
+        if (this._settlers.length > 0) {
+          throw new Error('Illegal internal state');
+        }
 
-    if (this._closed) {
-      if (this._settlers.length > 0) {
-        throw new Error('Illegal internal state');
+        return Promise.resolve({
+          done: true,
+          value: undefined
+        });
       }
 
-      return Promise.resolve({
-        done: true,
-        value: undefined
+      return new Promise(function (resolve, reject) {
+        _this._settlers.push({
+          resolve: resolve,
+          reject: reject
+        });
       });
     }
-
-    return new Promise((resolve, reject) => {
-      this._settlers.push({
-        resolve,
-        reject
-      });
-    });
-  }
-
-}
+  }]);
+  return AsyncQueue;
+}();
 
 exports.default = AsyncQueue;
 //# sourceMappingURL=async-queue.js.map

package/dist/es5/lib/async-queue/async-queue.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/async-queue/async-queue.ts"],"names":["Symbol","asyncIterator","AsyncQueue","constructor","_values","_settlers","_closed","push","value","enqueue","Error","length","settler","shift","reject","resolve","close","done","next","Promise","undefined"],"mappings":";;;;;;;;;;;;;wBA2BGA,MAAM,CAACC,a;;AAZK,MAAMC,UAAN,CAAoB;AAKjCC,EAAAA,WAAW,GAAG;AAAA;AAAA;AAAA;AACZ,SAAKC,OAAL,GAAe,EAAf;AACA,SAAKC,SAAL,GAAiB,EAAjB;AACA,SAAKC,OAAL,GAAe,KAAf;AACD;;AAGD,4BAA2C;AACzC,WAAO,IAAP;AACD;;AAGDC,EAAAA,IAAI,CAACC,KAAD,EAAiB;AACnB,WAAO,KAAKC,OAAL,CAAaD,KAAb,CAAP;AACD;;AAMDC,EAAAA,OAAO,CAACD,KAAD,EAAyB;AAC9B,QAAI,KAAKF,OAAT,EAAkB;AAChB,YAAM,IAAII,KAAJ,CAAU,QAAV,CAAN;AACD;;AAED,QAAI,KAAKL,SAAL,CAAeM,MAAf,GAAwB,CAA5B,EAA+B;AAC7B,UAAI,KAAKP,OAAL,CAAaO,MAAb,GAAsB,CAA1B,EAA6B;AAC3B,cAAM,IAAID,KAAJ,CAAU,wBAAV,CAAN;AACD;;AACD,YAAME,OAAO,GAAG,KAAKP,SAAL,CAAeQ,KAAf,EAAhB;;AACA,UAAIL,KAAK,YAAYE,KAArB,EAA4B;AAC1BE,QAAAA,OAAO,CAACE,MAAR,CAAeN,KAAf;AACD,OAFD,MAEO;AACLI,QAAAA,OAAO,CAACG,OAAR,CAAgB;AAACP,UAAAA;AAAD,SAAhB;AACD;AACF,KAVD,MAUO;AACL,WAAKJ,OAAL,CAAaG,IAAb,CAAkBC,KAAlB;AACD;AACF;;AAGDQ,EAAAA,KAAK,GAAS;AACZ,WAAO,KAAKX,SAAL,CAAeM,MAAf,GAAwB,CAA/B,EAAkC;AAChC,YAAMC,OAAO,GAAG,KAAKP,SAAL,CAAeQ,KAAf,EAAhB;;AACAD,MAAAA,OAAO,CAACG,OAAR,CAAgB;AAACE,QAAAA,IAAI,EAAE;AAAP,OAAhB;AACD;;AACD,SAAKX,OAAL,GAAe,IAAf;AACD;;AAKDY,EAAAA,IAAI,GAAoC;AAEtC,QAAI,KAAKd,OAAL,CAAaO,MAAb,GAAsB,CAA1B,EAA6B;AAC3B,YAAMH,KAAK,GAAG,KAAKJ,OAAL,CAAaS,KAAb,EAAd;;AACA,UAAIL,KAAK,YAAYE,KAArB,EAA4B;AAC1B,eAAOS,OAAO,CAACL,MAAR,CAAeN,KAAf,CAAP;AACD;;AACD,aAAOW,OAAO,CAACJ,OAAR,CAAgB;AAACE,QAAAA,IAAI,EAAE,KAAP;AAAcT,QAAAA;AAAd,OAAhB,CAAP;AACD;;AAGD,QAAI,KAAKF,OAAT,EAAkB;AAChB,UAAI,KAAKD,SAAL,CAAeM,MAAf,GAAwB,CAA5B,EAA+B;AAC7B,cAAM,IAAID,KAAJ,CAAU,wBAAV,CAAN;AACD;;AACD,aAAOS,OAAO,CAACJ,OAAR,CAAgB;AAACE,QAAAA,IAAI,EAAE,IAAP;AAAaT,QAAAA,KAAK,EAAEY;AAApB,OAAhB,CAAP;AACD;;AAGD,WAAO,IAAID,OAAJ,CAAY,CAACJ,OAAD,EAAUD,MAAV,KAAqB;AACtC,WAAKT,SAAL,CAAeE,IAAf,CAAoB;AAACQ,QAAAA,OAAD;AAAUD,QAAAA;AAAV,OAApB;AACD,KAFM,CAAP;AAGD;;AA/EgC","sourcesContent":["// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license\n// http://2ality.com/2016/10/asynchronous-iteration.html\n\n/**\n * Async Queue\n * - AsyncIterable: An async iterator can be\n * - Values can be pushed onto the queue\n * @example\n *   const asyncQueue = new AsyncQueue();\n *   setTimeout(() => asyncQueue.enqueue('tick'), 1000);\n *   setTimeout(() => asyncQueue.enqueue(new Error('done')), 10000);\n *   for await (const value of asyncQueue) {\n *     console.log(value); // tick\n *   }\n */\nexport default class AsyncQueue<T> {\n  private _values: any[];\n  private _settlers: any[];\n  private _closed: boolean;\n\n  constructor() {\n    this._values = []; // enqueues > dequeues\n    this._settlers = []; // dequeues > enqueues\n    this._closed = false;\n  }\n\n  /** Return an async iterator for this queue */\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return this;\n  }\n\n  /** Push a new value - the async iterator will yield a promise resolved to this value */\n  push(value: T): void {\n    return this.enqueue(value);\n  }\n\n  /**\n   * Push a new value - the async iterator will yield a promise resolved to this value\n   * Add an error - the async iterator will yield a promise rejected with this value\n   */\n  enqueue(value: T | Error): void {\n    if (this._closed) {\n      throw new Error('Closed');\n    }\n\n    if (this._settlers.length > 0) {\n      if (this._values.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      const settler = this._settlers.shift();\n      if (value instanceof Error) {\n        settler.reject(value);\n      } else {\n        settler.resolve({value});\n      }\n    } else {\n      this._values.push(value);\n    }\n  }\n\n  /** Indicate that we not waiting for more values - The async iterator will be done */\n  close(): void {\n    while (this._settlers.length > 0) {\n      const settler = this._settlers.shift();\n      settler.resolve({done: true});\n    }\n    this._closed = true;\n  }\n\n  // ITERATOR IMPLEMENTATION\n\n  /** @returns a Promise for an IteratorResult */\n  next(): Promise<IteratorResult<T, any>> {\n    // If values in queue, yield the first value\n    if (this._values.length > 0) {\n      const value = this._values.shift();\n      if (value instanceof Error) {\n        return Promise.reject(value);\n      }\n      return Promise.resolve({done: false, value});\n    }\n\n    // If queue is closed, the iterator is done\n    if (this._closed) {\n      if (this._settlers.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      return Promise.resolve({done: true, value: undefined});\n    }\n\n    // Yield a promise that waits for new values to be enqueued\n    return new Promise((resolve, reject) => {\n      this._settlers.push({resolve, reject});\n    });\n  }\n}\n"],"file":"async-queue.js"}
+{"version":3,"sources":["../../../../src/lib/async-queue/async-queue.ts"],"names":["Symbol","asyncIterator","AsyncQueue","_values","_settlers","_closed","value","enqueue","Error","length","settler","shift","reject","resolve","push","done","Promise","undefined"],"mappings":";;;;;;;;;;;;;;;;;wBA2BGA,MAAM,CAACC,a;;IAZWC,U;AAKnB,wBAAc;AAAA;AAAA;AAAA;AAAA;AACZ,SAAKC,OAAL,GAAe,EAAf;AACA,SAAKC,SAAL,GAAiB,EAAjB;AACA,SAAKC,OAAL,GAAe,KAAf;AACD;;;;WAGD,iBAA2C;AACzC,aAAO,IAAP;AACD;;;WAGD,cAAKC,KAAL,EAAqB;AACnB,aAAO,KAAKC,OAAL,CAAaD,KAAb,CAAP;AACD;;;WAMD,iBAAQA,KAAR,EAAgC;AAC9B,UAAI,KAAKD,OAAT,EAAkB;AAChB,cAAM,IAAIG,KAAJ,CAAU,QAAV,CAAN;AACD;;AAED,UAAI,KAAKJ,SAAL,CAAeK,MAAf,GAAwB,CAA5B,EAA+B;AAC7B,YAAI,KAAKN,OAAL,CAAaM,MAAb,GAAsB,CAA1B,EAA6B;AAC3B,gBAAM,IAAID,KAAJ,CAAU,wBAAV,CAAN;AACD;;AACD,YAAME,OAAO,GAAG,KAAKN,SAAL,CAAeO,KAAf,EAAhB;;AACA,YAAIL,KAAK,YAAYE,KAArB,EAA4B;AAC1BE,UAAAA,OAAO,CAACE,MAAR,CAAeN,KAAf;AACD,SAFD,MAEO;AACLI,UAAAA,OAAO,CAACG,OAAR,CAAgB;AAACP,YAAAA,KAAK,EAALA;AAAD,WAAhB;AACD;AACF,OAVD,MAUO;AACL,aAAKH,OAAL,CAAaW,IAAb,CAAkBR,KAAlB;AACD;AACF;;;WAGD,iBAAc;AACZ,aAAO,KAAKF,SAAL,CAAeK,MAAf,GAAwB,CAA/B,EAAkC;AAChC,YAAMC,OAAO,GAAG,KAAKN,SAAL,CAAeO,KAAf,EAAhB;;AACAD,QAAAA,OAAO,CAACG,OAAR,CAAgB;AAACE,UAAAA,IAAI,EAAE;AAAP,SAAhB;AACD;;AACD,WAAKV,OAAL,GAAe,IAAf;AACD;;;WAKD,gBAAwC;AAAA;;AAEtC,UAAI,KAAKF,OAAL,CAAaM,MAAb,GAAsB,CAA1B,EAA6B;AAC3B,YAAMH,KAAK,GAAG,KAAKH,OAAL,CAAaQ,KAAb,EAAd;;AACA,YAAIL,KAAK,YAAYE,KAArB,EAA4B;AAC1B,iBAAOQ,OAAO,CAACJ,MAAR,CAAeN,KAAf,CAAP;AACD;;AACD,eAAOU,OAAO,CAACH,OAAR,CAAgB;AAACE,UAAAA,IAAI,EAAE,KAAP;AAAcT,UAAAA,KAAK,EAALA;AAAd,SAAhB,CAAP;AACD;;AAGD,UAAI,KAAKD,OAAT,EAAkB;AAChB,YAAI,KAAKD,SAAL,CAAeK,MAAf,GAAwB,CAA5B,EAA+B;AAC7B,gBAAM,IAAID,KAAJ,CAAU,wBAAV,CAAN;AACD;;AACD,eAAOQ,OAAO,CAACH,OAAR,CAAgB;AAACE,UAAAA,IAAI,EAAE,IAAP;AAAaT,UAAAA,KAAK,EAAEW;AAApB,SAAhB,CAAP;AACD;;AAGD,aAAO,IAAID,OAAJ,CAAY,UAACH,OAAD,EAAUD,MAAV,EAAqB;AACtC,QAAA,KAAI,CAACR,SAAL,CAAeU,IAAf,CAAoB;AAACD,UAAAA,OAAO,EAAPA,OAAD;AAAUD,UAAAA,MAAM,EAANA;AAAV,SAApB;AACD,OAFM,CAAP;AAGD","sourcesContent":["// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license\n// http://2ality.com/2016/10/asynchronous-iteration.html\n\n/**\n * Async Queue\n * - AsyncIterable: An async iterator can be\n * - Values can be pushed onto the queue\n * @example\n *   const asyncQueue = new AsyncQueue();\n *   setTimeout(() => asyncQueue.enqueue('tick'), 1000);\n *   setTimeout(() => asyncQueue.enqueue(new Error('done')), 10000);\n *   for await (const value of asyncQueue) {\n *     console.log(value); // tick\n *   }\n */\nexport default class AsyncQueue<T> {\n  private _values: any[];\n  private _settlers: any[];\n  private _closed: boolean;\n\n  constructor() {\n    this._values = []; // enqueues > dequeues\n    this._settlers = []; // dequeues > enqueues\n    this._closed = false;\n  }\n\n  /** Return an async iterator for this queue */\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return this;\n  }\n\n  /** Push a new value - the async iterator will yield a promise resolved to this value */\n  push(value: T): void {\n    return this.enqueue(value);\n  }\n\n  /**\n   * Push a new value - the async iterator will yield a promise resolved to this value\n   * Add an error - the async iterator will yield a promise rejected with this value\n   */\n  enqueue(value: T | Error): void {\n    if (this._closed) {\n      throw new Error('Closed');\n    }\n\n    if (this._settlers.length > 0) {\n      if (this._values.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      const settler = this._settlers.shift();\n      if (value instanceof Error) {\n        settler.reject(value);\n      } else {\n        settler.resolve({value});\n      }\n    } else {\n      this._values.push(value);\n    }\n  }\n\n  /** Indicate that we not waiting for more values - The async iterator will be done */\n  close(): void {\n    while (this._settlers.length > 0) {\n      const settler = this._settlers.shift();\n      settler.resolve({done: true});\n    }\n    this._closed = true;\n  }\n\n  // ITERATOR IMPLEMENTATION\n\n  /** @returns a Promise for an IteratorResult */\n  next(): Promise<IteratorResult<T, any>> {\n    // If values in queue, yield the first value\n    if (this._values.length > 0) {\n      const value = this._values.shift();\n      if (value instanceof Error) {\n        return Promise.reject(value);\n      }\n      return Promise.resolve({done: false, value});\n    }\n\n    // If queue is closed, the iterator is done\n    if (this._closed) {\n      if (this._settlers.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      return Promise.resolve({done: true, value: undefined});\n    }\n\n    // Yield a promise that waits for new values to be enqueued\n    return new Promise((resolve, reject) => {\n      this._settlers.push({resolve, reject});\n    });\n  }\n}\n"],"file":"async-queue.js"}

package/dist/es5/lib/env-utils/globals.js

@@ -1,30 +1,35 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.nodeVersion = exports.isMobile = exports.isWorker = exports.isBrowser = exports.document = exports.global = exports.window = exports.self = void 0;
-const globals = {
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var globals = {
   self: typeof self !== 'undefined' && self,
   window: typeof window !== 'undefined' && window,
   global: typeof global !== 'undefined' && global,
   document: typeof document !== 'undefined' && document
 };
-const self_ = globals.self || globals.window || globals.global || {};
+var self_ = globals.self || globals.window || globals.global || {};
 exports.self = self_;
-const window_ = globals.window || globals.self || globals.global || {};
+var window_ = globals.window || globals.self || globals.global || {};
 exports.window = window_;
-const global_ = globals.global || globals.self || globals.window || {};
+var global_ = globals.global || globals.self || globals.window || {};
 exports.global = global_;
-const document_ = globals.document || {};
+var document_ = globals.document || {};
 exports.document = document_;
-const isBrowser = typeof process !== 'object' || String(process) !== '[object process]' || process.browser;
+var isBrowser = (typeof process === "undefined" ? "undefined" : (0, _typeof2.default)(process)) !== 'object' || String(process) !== '[object process]' || process.browser;
 exports.isBrowser = isBrowser;
-const isWorker = typeof importScripts === 'function';
+var isWorker = typeof importScripts === 'function';
 exports.isWorker = isWorker;
-const isMobile = typeof window !== 'undefined' && typeof window.orientation !== 'undefined';
+var isMobile = typeof window !== 'undefined' && typeof window.orientation !== 'undefined';
 exports.isMobile = isMobile;
-const matches = typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
-const nodeVersion = matches && parseFloat(matches[1]) || 0;
+var matches = typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
+var nodeVersion = matches && parseFloat(matches[1]) || 0;
 exports.nodeVersion = nodeVersion;
 //# sourceMappingURL=globals.js.map

package/dist/es5/lib/env-utils/globals.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/env-utils/globals.ts"],"names":["globals","self","window","global","document","self_","window_","global_","document_","isBrowser","process","String","browser","isWorker","importScripts","isMobile","orientation","matches","version","exec","nodeVersion","parseFloat"],"mappings":";;;;;;AAIA,MAAMA,OAAO,GAAG;AACdC,EAAAA,IAAI,EAAE,OAAOA,IAAP,KAAgB,WAAhB,IAA+BA,IADvB;AAEdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAF3B;AAGdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAH3B;AAIdC,EAAAA,QAAQ,EAAE,OAAOA,QAAP,KAAoB,WAApB,IAAmCA;AAJ/B,CAAhB;AAOA,MAAMC,KAA2B,GAAGL,OAAO,CAACC,IAAR,IAAgBD,OAAO,CAACE,MAAxB,IAAkCF,OAAO,CAACG,MAA1C,IAAoD,EAAxF;;AACA,MAAMG,OAA6B,GAAGN,OAAO,CAACE,MAAR,IAAkBF,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACG,MAA1C,IAAoD,EAA1F;;AACA,MAAMI,OAA6B,GAAGP,OAAO,CAACG,MAAR,IAAkBH,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACE,MAA1C,IAAoD,EAA1F;;AACA,MAAMM,SAA+B,GAAGR,OAAO,CAACI,QAAR,IAAoB,EAA5D;;AAKO,MAAMK,SAAkB,GAE7B,OAAOC,OAAP,KAAmB,QAAnB,IAA+BC,MAAM,CAACD,OAAD,CAAN,KAAoB,kBAAnD,IAAyEA,OAAO,CAACE,OAF5E;;AAKA,MAAMC,QAAiB,GAAG,OAAOC,aAAP,KAAyB,UAAnD;;AAGA,MAAMC,QAAiB,GAC5B,OAAOb,MAAP,KAAkB,WAAlB,IAAiC,OAAOA,MAAM,CAACc,WAAd,KAA8B,WAD1D;;AAIP,MAAMC,OAAO,GACX,OAAOP,OAAP,KAAmB,WAAnB,IAAkCA,OAAO,CAACQ,OAA1C,IAAqD,YAAYC,IAAZ,CAAiBT,OAAO,CAACQ,OAAzB,CADvD;AAIO,MAAME,WAAmB,GAAIH,OAAO,IAAII,UAAU,CAACJ,OAAO,CAAC,CAAD,CAAR,CAAtB,IAAuC,CAAnE","sourcesContent":["// Purpose: include this in your module to avoids adding dependencies on\n// micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals */\nconst globals = {\n  self: typeof self !== 'undefined' && self,\n  window: typeof window !== 'undefined' && window,\n  global: typeof global !== 'undefined' && global,\n  document: typeof document !== 'undefined' && document\n};\n\nconst self_: {[key: string]: any} = globals.self || globals.window || globals.global || {};\nconst window_: {[key: string]: any} = globals.window || globals.self || globals.global || {};\nconst global_: {[key: string]: any} = globals.global || globals.self || globals.window || {};\nconst document_: {[key: string]: any} = globals.document || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\n/** true if running in the browser, false if running in Node.js */\nexport const isBrowser: boolean =\n  // @ts-ignore process.browser\n  typeof process !== 'object' || String(process) !== '[object process]' || process.browser;\n\n/** true if running on a worker thread */\nexport const isWorker: boolean = typeof importScripts === 'function';\n\n/** true if running on a mobile device */\nexport const isMobile: boolean =\n  typeof window !== 'undefined' && typeof window.orientation !== 'undefined';\n\n// Extract node major version\nconst matches =\n  typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\n\n/** Version of Node.js if running under Node, otherwise 0 */\nexport const nodeVersion: number = (matches && parseFloat(matches[1])) || 0;\n"],"file":"globals.js"}
+{"version":3,"sources":["../../../../src/lib/env-utils/globals.ts"],"names":["globals","self","window","global","document","self_","window_","global_","document_","isBrowser","process","String","browser","isWorker","importScripts","isMobile","orientation","matches","version","exec","nodeVersion","parseFloat"],"mappings":";;;;;;;;;;;AAIA,IAAMA,OAAO,GAAG;AACdC,EAAAA,IAAI,EAAE,OAAOA,IAAP,KAAgB,WAAhB,IAA+BA,IADvB;AAEdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAF3B;AAGdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAH3B;AAIdC,EAAAA,QAAQ,EAAE,OAAOA,QAAP,KAAoB,WAApB,IAAmCA;AAJ/B,CAAhB;AAOA,IAAMC,KAA2B,GAAGL,OAAO,CAACC,IAAR,IAAgBD,OAAO,CAACE,MAAxB,IAAkCF,OAAO,CAACG,MAA1C,IAAoD,EAAxF;;AACA,IAAMG,OAA6B,GAAGN,OAAO,CAACE,MAAR,IAAkBF,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACG,MAA1C,IAAoD,EAA1F;;AACA,IAAMI,OAA6B,GAAGP,OAAO,CAACG,MAAR,IAAkBH,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACE,MAA1C,IAAoD,EAA1F;;AACA,IAAMM,SAA+B,GAAGR,OAAO,CAACI,QAAR,IAAoB,EAA5D;;AAKO,IAAMK,SAAkB,GAE7B,QAAOC,OAAP,uDAAOA,OAAP,OAAmB,QAAnB,IAA+BC,MAAM,CAACD,OAAD,CAAN,KAAoB,kBAAnD,IAAyEA,OAAO,CAACE,OAF5E;;AAKA,IAAMC,QAAiB,GAAG,OAAOC,aAAP,KAAyB,UAAnD;;AAGA,IAAMC,QAAiB,GAC5B,OAAOb,MAAP,KAAkB,WAAlB,IAAiC,OAAOA,MAAM,CAACc,WAAd,KAA8B,WAD1D;;AAIP,IAAMC,OAAO,GACX,OAAOP,OAAP,KAAmB,WAAnB,IAAkCA,OAAO,CAACQ,OAA1C,IAAqD,YAAYC,IAAZ,CAAiBT,OAAO,CAACQ,OAAzB,CADvD;AAIO,IAAME,WAAmB,GAAIH,OAAO,IAAII,UAAU,CAACJ,OAAO,CAAC,CAAD,CAAR,CAAtB,IAAuC,CAAnE","sourcesContent":["// Purpose: include this in your module to avoids adding dependencies on\n// micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals */\nconst globals = {\n  self: typeof self !== 'undefined' && self,\n  window: typeof window !== 'undefined' && window,\n  global: typeof global !== 'undefined' && global,\n  document: typeof document !== 'undefined' && document\n};\n\nconst self_: {[key: string]: any} = globals.self || globals.window || globals.global || {};\nconst window_: {[key: string]: any} = globals.window || globals.self || globals.global || {};\nconst global_: {[key: string]: any} = globals.global || globals.self || globals.window || {};\nconst document_: {[key: string]: any} = globals.document || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\n/** true if running in the browser, false if running in Node.js */\nexport const isBrowser: boolean =\n  // @ts-ignore process.browser\n  typeof process !== 'object' || String(process) !== '[object process]' || process.browser;\n\n/** true if running on a worker thread */\nexport const isWorker: boolean = typeof importScripts === 'function';\n\n/** true if running on a mobile device */\nexport const isMobile: boolean =\n  typeof window !== 'undefined' && typeof window.orientation !== 'undefined';\n\n// Extract node major version\nconst matches =\n  typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\n\n/** Version of Node.js if running under Node, otherwise 0 */\nexport const nodeVersion: number = (matches && parseFloat(matches[1])) || 0;\n"],"file":"globals.js"}

package/dist/es5/lib/env-utils/version.js

@@ -4,11 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.VERSION = void 0;
-const DEFAULT_VERSION = 'beta';
-const VERSION = typeof "3.1.0-beta.4" !== 'undefined' ? "3.1.0-beta.4" : DEFAULT_VERSION;
+var DEFAULT_VERSION = 'beta';
+var VERSION = typeof "3.1.0" !== 'undefined' ? "3.1.0" : DEFAULT_VERSION;
 exports.VERSION = VERSION;
 
-if (typeof "3.1.0-beta.4" === 'undefined') {
+if (typeof "3.1.0" === 'undefined') {
   console.error('loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.');
 }
 //# sourceMappingURL=version.js.map

package/dist/es5/lib/env-utils/version.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/env-utils/version.ts"],"names":["DEFAULT_VERSION","VERSION","console","error"],"mappings":";;;;;;AAIA,MAAMA,eAAe,GAAG,MAAxB;AAEO,MAAMC,OAAO,GAAG,0BAAuB,WAAvB,oBAAmDD,eAAnE;;;AACP,IAAI,0BAAuB,WAA3B,EAAwC;AAEtCE,EAAAA,OAAO,CAACC,KAAR,CACE,iIADF;AAGD","sourcesContent":["// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n\n// Change to `latest` on production branches\nconst DEFAULT_VERSION = 'beta';\ndeclare let __VERSION__: string;\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : DEFAULT_VERSION;\nif (typeof __VERSION__ === 'undefined') {\n  // eslint-disable-next-line\n  console.error(\n    'loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.'\n  );\n}\n"],"file":"version.js"}
+{"version":3,"sources":["../../../../src/lib/env-utils/version.ts"],"names":["DEFAULT_VERSION","VERSION","console","error"],"mappings":";;;;;;AAIA,IAAMA,eAAe,GAAG,MAAxB;AAEO,IAAMC,OAAO,GAAG,mBAAuB,WAAvB,aAAmDD,eAAnE;;;AACP,IAAI,mBAAuB,WAA3B,EAAwC;AAEtCE,EAAAA,OAAO,CAACC,KAAR,CACE,iIADF;AAGD","sourcesContent":["// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n\n// Change to `latest` on production branches\nconst DEFAULT_VERSION = 'beta';\ndeclare let __VERSION__: string;\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : DEFAULT_VERSION;\nif (typeof __VERSION__ === 'undefined') {\n  // eslint-disable-next-line\n  console.error(\n    'loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.'\n  );\n}\n"],"file":"version.js"}

package/dist/es5/lib/library-utils/library-utils.js

@@ -1,11 +1,19 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.loadLibrary = loadLibrary;
 exports.getLibraryUrl = getLibraryUrl;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _globals = require("../env-utils/globals");
 
 var node = _interopRequireWildcard(require("../node/require-utils.node"));
@@ -14,21 +22,49 @@ var _assert = require("../env-utils/assert");
 
 var _version = require("../env-utils/version");
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const LATEST = 'beta';
-const VERSION = typeof "3.1.0-beta.4" !== 'undefined' ? "3.1.0-beta.4" : LATEST;
-const loadLibraryPromises = {};
+var LATEST = 'beta';
+var VERSION = typeof "3.1.0" !== 'undefined' ? "3.1.0" : LATEST;
+var loadLibraryPromises = {};
 
-async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
-  if (moduleName) {
-    libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
-  }
+function loadLibrary(_x) {
+  return _loadLibrary.apply(this, arguments);
+}
 
-  loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
-  return await loadLibraryPromises[libraryUrl];
+function _loadLibrary() {
+  _loadLibrary = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(libraryUrl) {
+    var moduleName,
+        options,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            moduleName = _args.length > 1 && _args[1] !== undefined ? _args[1] : null;
+            options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+
+            if (moduleName) {
+              libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
+            }
+
+            loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+            _context.next = 6;
+            return loadLibraryPromises[libraryUrl];
+
+          case 6:
+            return _context.abrupt("return", _context.sent);
+
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _loadLibrary.apply(this, arguments);
 }
 
 function getLibraryUrl(library, moduleName, options) {
@@ -36,7 +72,7 @@ function getLibraryUrl(library, moduleName, options) {
     return library;
   }
 
-  const modules = options.modules || {};
+  var modules = options.modules || {};
 
   if (modules[library]) {
     return modules[library];
@@ -58,23 +94,85 @@ function getLibraryUrl(library, moduleName, options) {
   return "modules/".concat(moduleName, "/src/libs/").concat(library);
 }
 
-async function loadLibraryFromFile(libraryUrl) {
-  if (libraryUrl.endsWith('wasm')) {
-    const response = await fetch(libraryUrl);
-    return await response.arrayBuffer();
-  }
-
-  if (!_globals.isBrowser) {
-    return node.requireFromFile && (await node.requireFromFile(libraryUrl));
-  }
-
-  if (_globals.isWorker) {
-    return importScripts(libraryUrl);
-  }
+function loadLibraryFromFile(_x2) {
+  return _loadLibraryFromFile.apply(this, arguments);
+}
 
-  const response = await fetch(libraryUrl);
-  const scriptSource = await response.text();
-  return loadLibraryFromString(scriptSource, libraryUrl);
+function _loadLibraryFromFile() {
+  _loadLibraryFromFile = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(libraryUrl) {
+    var _response, response, scriptSource;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!libraryUrl.endsWith('wasm')) {
+              _context2.next = 7;
+              break;
+            }
+
+            _context2.next = 3;
+            return fetch(libraryUrl);
+
+          case 3:
+            _response = _context2.sent;
+            _context2.next = 6;
+            return _response.arrayBuffer();
+
+          case 6:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 7:
+            if (_globals.isBrowser) {
+              _context2.next = 14;
+              break;
+            }
+
+            _context2.t0 = node.requireFromFile;
+
+            if (!_context2.t0) {
+              _context2.next = 13;
+              break;
+            }
+
+            _context2.next = 12;
+            return node.requireFromFile(libraryUrl);
+
+          case 12:
+            _context2.t0 = _context2.sent;
+
+          case 13:
+            return _context2.abrupt("return", _context2.t0);
+
+          case 14:
+            if (!_globals.isWorker) {
+              _context2.next = 16;
+              break;
+            }
+
+            return _context2.abrupt("return", importScripts(libraryUrl));
+
+          case 16:
+            _context2.next = 18;
+            return fetch(libraryUrl);
+
+          case 18:
+            response = _context2.sent;
+            _context2.next = 21;
+            return response.text();
+
+          case 21:
+            scriptSource = _context2.sent;
+            return _context2.abrupt("return", loadLibraryFromString(scriptSource, libraryUrl));
+
+          case 23:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _loadLibraryFromFile.apply(this, arguments);
 }
 
 function loadLibraryFromString(scriptSource, id) {
@@ -87,7 +185,7 @@ function loadLibraryFromString(scriptSource, id) {
     return null;
   }
 
-  const script = document.createElement('script');
+  var script = document.createElement('script');
   script.id = id;
 
   try {