@loaders.gl/crypto 3.0.13 → 3.0.14

package/dist/es5/lib/crypto-hash.js

@@ -7,79 +7,255 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.CryptoHash = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _hash = require("./hash");
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
+var _hash2 = require("./hash");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-let CryptoJS;
+var CryptoJS;
 
-class CryptoHash extends _hash.Hash {
-  constructor(options) {
-    var _this$options, _this$options$crypto;
+var CryptoHash = function (_Hash) {
+  (0, _inherits2.default)(CryptoHash, _Hash);
 
-    super();
-    (0, _defineProperty2.default)(this, "name", void 0);
-    (0, _defineProperty2.default)(this, "options", void 0);
-    (0, _defineProperty2.default)(this, "_algorithm", void 0);
-    (0, _defineProperty2.default)(this, "_hash", void 0);
-    this.options = options;
-    this._algorithm = (_this$options = this.options) === null || _this$options === void 0 ? void 0 : (_this$options$crypto = _this$options.crypto) === null || _this$options$crypto === void 0 ? void 0 : _this$options$crypto.algorithm;
+  var _super = _createSuper(CryptoHash);
 
-    if (!this._algorithm) {
-      throw new Error(this.name);
+  function CryptoHash(options) {
+    var _this2$options, _this2$options$crypto;
+
+    var _this2;
+
+    (0, _classCallCheck2.default)(this, CryptoHash);
+    _this2 = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), "name", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), "options", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), "_algorithm", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), "_hash", void 0);
+    _this2.options = options;
+    _this2._algorithm = (_this2$options = _this2.options) === null || _this2$options === void 0 ? void 0 : (_this2$options$crypto = _this2$options.crypto) === null || _this2$options$crypto === void 0 ? void 0 : _this2$options$crypto.algorithm;
+
+    if (!_this2._algorithm) {
+      throw new Error(_this2.name);
     }
 
-    this.name = this._algorithm.toLowerCase();
+    _this2.name = _this2._algorithm.toLowerCase();
+    return _this2;
   }
 
-  async preload() {
-    if (!CryptoJS) {
-      var _this$options2, _this$options2$module;
+  (0, _createClass2.default)(CryptoHash, [{
+    key: "preload",
+    value: function () {
+      var _preload = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+        var _this$options, _this$options$modules, algo;
+
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (CryptoJS) {
+                  _context.next = 4;
+                  break;
+                }
+
+                CryptoJS = (_this$options = this.options) === null || _this$options === void 0 ? void 0 : (_this$options$modules = _this$options.modules) === null || _this$options$modules === void 0 ? void 0 : _this$options$modules.CryptoJS;
+
+                if (CryptoJS) {
+                  _context.next = 4;
+                  break;
+                }
 
-      CryptoJS = (_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : (_this$options2$module = _this$options2.modules) === null || _this$options2$module === void 0 ? void 0 : _this$options2$module.CryptoJS;
+                throw new Error(this.name);
 
-      if (!CryptoJS) {
-        throw new Error(this.name);
+              case 4:
+                if (!this._hash) {
+                  algo = CryptoJS.algo[this._algorithm];
+                  this._hash = algo.create();
+                }
+
+                if (this._hash) {
+                  _context.next = 7;
+                  break;
+                }
+
+                throw new Error(this.name);
+
+              case 7:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function preload() {
+        return _preload.apply(this, arguments);
       }
-    }
 
-    if (!this._hash) {
-      const algo = CryptoJS.algo[this._algorithm];
-      this._hash = algo.create();
-    }
+      return preload;
+    }()
+  }, {
+    key: "hash",
+    value: function () {
+      var _hash = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(input) {
+        var typedWordArray;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return this.preload();
 
-    if (!this._hash) {
-      throw new Error(this.name);
-    }
-  }
+              case 2:
+                typedWordArray = CryptoJS.lib.WordArray.create(input);
+                return _context2.abrupt("return", this._hash.update(typedWordArray).finalize().toString(CryptoJS.enc.Base64));
 
-  async hash(input) {
-    await this.preload();
-    const typedWordArray = CryptoJS.lib.WordArray.create(input);
-    return this._hash.update(typedWordArray).finalize().toString(CryptoJS.enc.Base64);
-  }
+              case 4:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
 
-  async *hashBatches(asyncIterator) {
-    var _this$options3, _this$options3$crypto, _this$options3$crypto2;
+      function hash(_x) {
+        return _hash.apply(this, arguments);
+      }
 
-    await this.preload();
+      return hash;
+    }()
+  }, {
+    key: "hashBatches",
+    value: function hashBatches(asyncIterator) {
+      var _this = this;
 
-    for await (const chunk of asyncIterator) {
-      const typedWordArray = CryptoJS.lib.WordArray.create(chunk);
+      return (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee3() {
+        var _this$options2, _this$options2$crypto, _this$options2$crypto2;
 
-      this._hash.update(typedWordArray);
+        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, typedWordArray, hash;
 
-      yield chunk;
-    }
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return (0, _awaitAsyncGenerator2.default)(_this.preload());
 
-    const hash = this._hash.finalize().toString(CryptoJS.enc.Base64);
+              case 2:
+                _iteratorNormalCompletion = true;
+                _didIteratorError = false;
+                _context3.prev = 4;
+                _iterator = (0, _asyncIterator2.default)(asyncIterator);
 
-    (_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : (_this$options3$crypto = _this$options3.crypto) === null || _this$options3$crypto === void 0 ? void 0 : (_this$options3$crypto2 = _this$options3$crypto.onEnd) === null || _this$options3$crypto2 === void 0 ? void 0 : _this$options3$crypto2.call(_this$options3$crypto, {
-      hash
-    });
-  }
+              case 6:
+                _context3.next = 8;
+                return (0, _awaitAsyncGenerator2.default)(_iterator.next());
+
+              case 8:
+                _step = _context3.sent;
+                _iteratorNormalCompletion = _step.done;
+                _context3.next = 12;
+                return (0, _awaitAsyncGenerator2.default)(_step.value);
+
+              case 12:
+                _value = _context3.sent;
+
+                if (_iteratorNormalCompletion) {
+                  _context3.next = 22;
+                  break;
+                }
+
+                chunk = _value;
+                typedWordArray = CryptoJS.lib.WordArray.create(chunk);
+
+                _this._hash.update(typedWordArray);
+
+                _context3.next = 19;
+                return chunk;
+
+              case 19:
+                _iteratorNormalCompletion = true;
+                _context3.next = 6;
+                break;
 
-}
+              case 22:
+                _context3.next = 28;
+                break;
+
+              case 24:
+                _context3.prev = 24;
+                _context3.t0 = _context3["catch"](4);
+                _didIteratorError = true;
+                _iteratorError = _context3.t0;
+
+              case 28:
+                _context3.prev = 28;
+                _context3.prev = 29;
+
+                if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
+                  _context3.next = 33;
+                  break;
+                }
+
+                _context3.next = 33;
+                return (0, _awaitAsyncGenerator2.default)(_iterator.return());
+
+              case 33:
+                _context3.prev = 33;
+
+                if (!_didIteratorError) {
+                  _context3.next = 36;
+                  break;
+                }
+
+                throw _iteratorError;
+
+              case 36:
+                return _context3.finish(33);
+
+              case 37:
+                return _context3.finish(28);
+
+              case 38:
+                hash = _this._hash.finalize().toString(CryptoJS.enc.Base64);
+                (_this$options2 = _this.options) === null || _this$options2 === void 0 ? void 0 : (_this$options2$crypto = _this$options2.crypto) === null || _this$options2$crypto === void 0 ? void 0 : (_this$options2$crypto2 = _this$options2$crypto.onEnd) === null || _this$options2$crypto2 === void 0 ? void 0 : _this$options2$crypto2.call(_this$options2$crypto, {
+                  hash: hash
+                });
+
+              case 40:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, null, [[4, 24, 28, 38], [29,, 33, 37]]);
+      }))();
+    }
+  }]);
+  return CryptoHash;
+}(_hash2.Hash);
 
 exports.CryptoHash = CryptoHash;
 //# sourceMappingURL=crypto-hash.js.map

package/dist/es5/lib/crypto-hash.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/crypto-hash.ts"],"names":["CryptoJS","CryptoHash","Hash","constructor","options","_algorithm","crypto","algorithm","Error","name","toLowerCase","preload","modules","_hash","algo","create","hash","input","typedWordArray","lib","WordArray","update","finalize","toString","enc","Base64","hashBatches","asyncIterator","chunk","onEnd"],"mappings":";;;;;;;;;;;AAEA;;AAUA,IAAIA,QAAJ;;AAMO,MAAMC,UAAN,SAAyBC,UAAzB,CAA8B;AAOnCC,EAAAA,WAAW,CAACC,OAAD,EAA6B;AAAA;;AACtC;AADsC;AAAA;AAAA;AAAA;AAEtC,SAAKA,OAAL,GAAeA,OAAf;AACA,SAAKC,UAAL,oBAAkB,KAAKD,OAAvB,0EAAkB,cAAcE,MAAhC,yDAAkB,qBAAsBC,SAAxC;;AACA,QAAI,CAAC,KAAKF,UAAV,EAAsB;AACpB,YAAM,IAAIG,KAAJ,CAAU,KAAKC,IAAf,CAAN;AACD;;AACD,SAAKA,IAAL,GAAY,KAAKJ,UAAL,CAAgBK,WAAhB,EAAZ;AACD;;AAEY,QAAPC,OAAO,GAAkB;AAC7B,QAAI,CAACX,QAAL,EAAe;AAAA;;AACbA,MAAAA,QAAQ,qBAAG,KAAKI,OAAR,4EAAG,eAAcQ,OAAjB,0DAAG,sBAAuBZ,QAAlC;;AACA,UAAI,CAACA,QAAL,EAAe;AACb,cAAM,IAAIQ,KAAJ,CAAU,KAAKC,IAAf,CAAN;AACD;AACF;;AACD,QAAI,CAAC,KAAKI,KAAV,EAAiB;AACf,YAAMC,IAAI,GAAGd,QAAQ,CAACc,IAAT,CAAc,KAAKT,UAAnB,CAAb;AACA,WAAKQ,KAAL,GAAaC,IAAI,CAACC,MAAL,EAAb;AACD;;AACD,QAAI,CAAC,KAAKF,KAAV,EAAiB;AACf,YAAM,IAAIL,KAAJ,CAAU,KAAKC,IAAf,CAAN;AACD;AACF;;AAMS,QAAJO,IAAI,CAACC,KAAD,EAAsC;AAC9C,UAAM,KAAKN,OAAL,EAAN;AAIA,UAAMO,cAAc,GAAGlB,QAAQ,CAACmB,GAAT,CAAaC,SAAb,CAAuBL,MAAvB,CAA8BE,KAA9B,CAAvB;AACA,WAAO,KAAKJ,KAAL,CAAWQ,MAAX,CAAkBH,cAAlB,EAAkCI,QAAlC,GAA6CC,QAA7C,CAAsDvB,QAAQ,CAACwB,GAAT,CAAaC,MAAnE,CAAP;AACD;;AAEiB,SAAXC,WAAW,CAChBC,aADgB,EAEY;AAAA;;AAC5B,UAAM,KAAKhB,OAAL,EAAN;;AACA,eAAW,MAAMiB,KAAjB,IAA0BD,aAA1B,EAAyC;AAIvC,YAAMT,cAAc,GAAGlB,QAAQ,CAACmB,GAAT,CAAaC,SAAb,CAAuBL,MAAvB,CAA8Ba,KAA9B,CAAvB;;AACA,WAAKf,KAAL,CAAWQ,MAAX,CAAkBH,cAAlB;;AACA,YAAMU,KAAN;AACD;;AACD,UAAMZ,IAAI,GAAG,KAAKH,KAAL,CAAWS,QAAX,GAAsBC,QAAtB,CAA+BvB,QAAQ,CAACwB,GAAT,CAAaC,MAA5C,CAAb;;AACA,2BAAKrB,OAAL,2FAAcE,MAAd,0GAAsBuB,KAAtB,8GAA8B;AAACb,MAAAA;AAAD,KAA9B;AACD;;AA5DkC","sourcesContent":["// This dependency is too big, application must provide it\nimport type * as CryptoJSNamespace from 'crypto-js';\nimport {Hash} from './hash';\n\ntype CryptoHashOptions = {\n  modules: {[moduleName: string]: any};\n  crypto: {\n    algorithm: string;\n    onEnd?: (result: {hash: string}) => any;\n  };\n};\n\nlet CryptoJS: typeof CryptoJSNamespace;\n\n/**\n * A transform that calculates Cryptographic Hash using Crypto JS library\n * @deprecated Warning, experimental class\n */\nexport class CryptoHash extends Hash {\n  readonly name;\n\n  options: CryptoHashOptions;\n  private _algorithm;\n  private _hash;\n\n  constructor(options: CryptoHashOptions) {\n    super();\n    this.options = options;\n    this._algorithm = this.options?.crypto?.algorithm;\n    if (!this._algorithm) {\n      throw new Error(this.name);\n    }\n    this.name = this._algorithm.toLowerCase();\n  }\n\n  async preload(): Promise<void> {\n    if (!CryptoJS) {\n      CryptoJS = this.options?.modules?.CryptoJS;\n      if (!CryptoJS) {\n        throw new Error(this.name);\n      }\n    }\n    if (!this._hash) {\n      const algo = CryptoJS.algo[this._algorithm];\n      this._hash = algo.create();\n    }\n    if (!this._hash) {\n      throw new Error(this.name);\n    }\n  }\n\n  /**\n   * Atomic hash calculation\n   * @returns base64 encoded hash\n   */\n  async hash(input: ArrayBuffer): Promise<string> {\n    await this.preload();\n    // arrayBuffer is accepted, even though types and docs say no\n    // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer\n    // @ts-expect-error\n    const typedWordArray = CryptoJS.lib.WordArray.create(input);\n    return this._hash.update(typedWordArray).finalize().toString(CryptoJS.enc.Base64);\n  }\n\n  async *hashBatches(\n    asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n  ): AsyncIterable<ArrayBuffer> {\n    await this.preload();\n    for await (const chunk of asyncIterator) {\n      // arrayBuffer is accepted, even though types and docs say no\n      // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer\n      // @ts-expect-error\n      const typedWordArray = CryptoJS.lib.WordArray.create(chunk);\n      this._hash.update(typedWordArray);\n      yield chunk;\n    }\n    const hash = this._hash.finalize().toString(CryptoJS.enc.Base64);\n    this.options?.crypto?.onEnd?.({hash});\n  }\n}\n"],"file":"crypto-hash.js"}
+{"version":3,"sources":["../../../src/lib/crypto-hash.ts"],"names":["CryptoJS","CryptoHash","options","_algorithm","crypto","algorithm","Error","name","toLowerCase","modules","_hash","algo","create","input","preload","typedWordArray","lib","WordArray","update","finalize","toString","enc","Base64","asyncIterator","chunk","hash","onEnd","Hash"],"mappings":"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","sourcesContent":["// This dependency is too big, application must provide it\nimport type * as CryptoJSNamespace from 'crypto-js';\nimport {Hash} from './hash';\n\ntype CryptoHashOptions = {\n  modules: {[moduleName: string]: any};\n  crypto: {\n    algorithm: string;\n    onEnd?: (result: {hash: string}) => any;\n  };\n};\n\nlet CryptoJS: typeof CryptoJSNamespace;\n\n/**\n * A transform that calculates Cryptographic Hash using Crypto JS library\n * @deprecated Warning, experimental class\n */\nexport class CryptoHash extends Hash {\n  readonly name;\n\n  options: CryptoHashOptions;\n  private _algorithm;\n  private _hash;\n\n  constructor(options: CryptoHashOptions) {\n    super();\n    this.options = options;\n    this._algorithm = this.options?.crypto?.algorithm;\n    if (!this._algorithm) {\n      throw new Error(this.name);\n    }\n    this.name = this._algorithm.toLowerCase();\n  }\n\n  async preload(): Promise<void> {\n    if (!CryptoJS) {\n      CryptoJS = this.options?.modules?.CryptoJS;\n      if (!CryptoJS) {\n        throw new Error(this.name);\n      }\n    }\n    if (!this._hash) {\n      const algo = CryptoJS.algo[this._algorithm];\n      this._hash = algo.create();\n    }\n    if (!this._hash) {\n      throw new Error(this.name);\n    }\n  }\n\n  /**\n   * Atomic hash calculation\n   * @returns base64 encoded hash\n   */\n  async hash(input: ArrayBuffer): Promise<string> {\n    await this.preload();\n    // arrayBuffer is accepted, even though types and docs say no\n    // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer\n    // @ts-expect-error\n    const typedWordArray = CryptoJS.lib.WordArray.create(input);\n    return this._hash.update(typedWordArray).finalize().toString(CryptoJS.enc.Base64);\n  }\n\n  async *hashBatches(\n    asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n  ): AsyncIterable<ArrayBuffer> {\n    await this.preload();\n    for await (const chunk of asyncIterator) {\n      // arrayBuffer is accepted, even though types and docs say no\n      // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer\n      // @ts-expect-error\n      const typedWordArray = CryptoJS.lib.WordArray.create(chunk);\n      this._hash.update(typedWordArray);\n      yield chunk;\n    }\n    const hash = this._hash.finalize().toString(CryptoJS.enc.Base64);\n    this.options?.crypto?.onEnd?.({hash});\n  }\n}\n"],"file":"crypto-hash.js"}

package/dist/es5/lib/hash.js

@@ -7,43 +7,197 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Hash = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
 var _loaderUtils = require("@loaders.gl/loader-utils");
 
-class Hash {
-  constructor(options = {}) {
+var Hash = function () {
+  function Hash() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2.default)(this, Hash);
     (0, _defineProperty2.default)(this, "name", void 0);
     (0, _defineProperty2.default)(this, "options", void 0);
     this.hashBatches = this.hashBatches.bind(this);
   }
 
-  async preload() {
-    return;
-  }
+  (0, _createClass2.default)(Hash, [{
+    key: "preload",
+    value: function () {
+      var _preload = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                return _context.abrupt("return");
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function preload() {
+        return _preload.apply(this, arguments);
+      }
+
+      return preload;
+    }()
+  }, {
+    key: "hashBatches",
+    value: function hashBatches(asyncIterator) {
+      var _this = this;
+
+      return (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee2() {
+        var _this$options, _this$options$crypto, _this$options$crypto$;
+
+        var arrayBuffers, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, _arrayBuffer, output, hash;
+
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                arrayBuffers = [];
+                _iteratorNormalCompletion = true;
+                _didIteratorError = false;
+                _context2.prev = 3;
+                _iterator = (0, _asyncIterator2.default)(asyncIterator);
+
+              case 5:
+                _context2.next = 7;
+                return (0, _awaitAsyncGenerator2.default)(_iterator.next());
+
+              case 7:
+                _step = _context2.sent;
+                _iteratorNormalCompletion = _step.done;
+                _context2.next = 11;
+                return (0, _awaitAsyncGenerator2.default)(_step.value);
+
+              case 11:
+                _value = _context2.sent;
 
-  async *hashBatches(asyncIterator) {
-    var _this$options, _this$options$crypto, _this$options$crypto$;
+                if (_iteratorNormalCompletion) {
+                  _context2.next = 20;
+                  break;
+                }
 
-    const arrayBuffers = [];
+                _arrayBuffer = _value;
+                arrayBuffers.push(_arrayBuffer);
+                _context2.next = 17;
+                return _arrayBuffer;
 
-    for await (const arrayBuffer of asyncIterator) {
-      arrayBuffers.push(arrayBuffer);
-      yield arrayBuffer;
+              case 17:
+                _iteratorNormalCompletion = true;
+                _context2.next = 5;
+                break;
+
+              case 20:
+                _context2.next = 26;
+                break;
+
+              case 22:
+                _context2.prev = 22;
+                _context2.t0 = _context2["catch"](3);
+                _didIteratorError = true;
+                _iteratorError = _context2.t0;
+
+              case 26:
+                _context2.prev = 26;
+                _context2.prev = 27;
+
+                if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
+                  _context2.next = 31;
+                  break;
+                }
+
+                _context2.next = 31;
+                return (0, _awaitAsyncGenerator2.default)(_iterator.return());
+
+              case 31:
+                _context2.prev = 31;
+
+                if (!_didIteratorError) {
+                  _context2.next = 34;
+                  break;
+                }
+
+                throw _iteratorError;
+
+              case 34:
+                return _context2.finish(31);
+
+              case 35:
+                return _context2.finish(26);
+
+              case 36:
+                _context2.next = 38;
+                return (0, _awaitAsyncGenerator2.default)(_this.concatenate(arrayBuffers));
+
+              case 38:
+                output = _context2.sent;
+                _context2.next = 41;
+                return (0, _awaitAsyncGenerator2.default)(_this.hash(output));
+
+              case 41:
+                hash = _context2.sent;
+                (_this$options = _this.options) === null || _this$options === void 0 ? void 0 : (_this$options$crypto = _this$options.crypto) === null || _this$options$crypto === void 0 ? void 0 : (_this$options$crypto$ = _this$options$crypto.onEnd) === null || _this$options$crypto$ === void 0 ? void 0 : _this$options$crypto$.call(_this$options$crypto, {
+                  hash: hash
+                });
+
+              case 43:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, null, [[3, 22, 26, 36], [27,, 31, 35]]);
+      }))();
     }
+  }, {
+    key: "concatenate",
+    value: function () {
+      var _concatenate = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(asyncIterator) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return (0, _loaderUtils.concatenateArrayBuffersAsync)(asyncIterator);
 
-    const output = await this.concatenate(arrayBuffers);
-    const hash = await this.hash(output);
-    (_this$options = this.options) === null || _this$options === void 0 ? void 0 : (_this$options$crypto = _this$options.crypto) === null || _this$options$crypto === void 0 ? void 0 : (_this$options$crypto$ = _this$options$crypto.onEnd) === null || _this$options$crypto$ === void 0 ? void 0 : _this$options$crypto$.call(_this$options$crypto, {
-      hash
-    });
-  }
+              case 2:
+                return _context3.abrupt("return", _context3.sent);
 
-  async concatenate(asyncIterator) {
-    return await (0, _loaderUtils.concatenateArrayBuffersAsync)(asyncIterator);
-  }
+              case 3:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }));
+
+      function concatenate(_x) {
+        return _concatenate.apply(this, arguments);
+      }
 
-}
+      return concatenate;
+    }()
+  }]);
+  return Hash;
+}();
 
 exports.Hash = Hash;
 //# sourceMappingURL=hash.js.map

package/dist/es5/lib/hash.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/hash.ts"],"names":["Hash","constructor","options","hashBatches","bind","preload","asyncIterator","arrayBuffers","arrayBuffer","push","output","concatenate","hash","crypto","onEnd"],"mappings":";;;;;;;;;;;AACA;;AAUO,MAAeA,IAAf,CAAoB;AAIzBC,EAAAA,WAAW,CAACC,OAAoB,GAAG,EAAxB,EAA4B;AAAA;AAAA;AACrC,SAAKC,WAAL,GAAmB,KAAKA,WAAL,CAAiBC,IAAjB,CAAsB,IAAtB,CAAnB;AACD;;AAEY,QAAPC,OAAO,GAAkB;AAC7B;AACD;;AAIiB,SAAXF,WAAW,CAChBG,aADgB,EAEY;AAAA;;AAC5B,UAAMC,YAA2B,GAAG,EAApC;;AACA,eAAW,MAAMC,WAAjB,IAAgCF,aAAhC,EAA+C;AAC7CC,MAAAA,YAAY,CAACE,IAAb,CAAkBD,WAAlB;AACA,YAAMA,WAAN;AACD;;AACD,UAAME,MAAM,GAAG,MAAM,KAAKC,WAAL,CAAiBJ,YAAjB,CAArB;AACA,UAAMK,IAAI,GAAG,MAAM,KAAKA,IAAL,CAAUF,MAAV,CAAnB;AACA,0BAAKR,OAAL,wFAAcW,MAAd,uGAAsBC,KAAtB,2GAA8B;AAACF,MAAAA;AAAD,KAA9B;AACD;;AAI0B,QAAXD,WAAW,CAACL,aAAD,EAAsC;AAC/D,WAAO,MAAM,+CAA6BA,aAA7B,CAAb;AACD;;AA/BwB","sourcesContent":["// Hash\nimport {concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\ntype HashOptions = {\n  modules?: {[moduleName: string]: any};\n  crypto?: {\n    onEnd?: (result: {hash: string}) => any;\n  };\n};\n\n/** Abstract hash base class */\nexport abstract class Hash {\n  abstract readonly name: string;\n  abstract readonly options: HashOptions;\n\n  constructor(options: HashOptions = {}) {\n    this.hashBatches = this.hashBatches.bind(this);\n  }\n\n  async preload(): Promise<void> {\n    return;\n  }\n\n  abstract hash(arrayBuffer: ArrayBuffer): Promise<string>;\n\n  async *hashBatches(\n    asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n  ): AsyncIterable<ArrayBuffer> {\n    const arrayBuffers: ArrayBuffer[] = [];\n    for await (const arrayBuffer of asyncIterator) {\n      arrayBuffers.push(arrayBuffer);\n      yield arrayBuffer;\n    }\n    const output = await this.concatenate(arrayBuffers);\n    const hash = await this.hash(output);\n    this.options?.crypto?.onEnd?.({hash});\n  }\n\n  // HELPERS\n\n  protected async concatenate(asyncIterator): Promise<ArrayBuffer> {\n    return await concatenateArrayBuffersAsync(asyncIterator);\n  }\n}\n"],"file":"hash.js"}
+{"version":3,"sources":["../../../src/lib/hash.ts"],"names":["Hash","options","hashBatches","bind","asyncIterator","arrayBuffers","arrayBuffer","push","concatenate","output","hash","crypto","onEnd"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA;;IAUsBA,I;AAIpB,kBAAuC;AAAA,QAA3BC,OAA2B,uEAAJ,EAAI;AAAA;AAAA;AAAA;AACrC,SAAKC,WAAL,GAAmB,KAAKA,WAAL,CAAiBC,IAAjB,CAAsB,IAAtB,CAAnB;AACD;;;;;+EAED;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O;;;;;;;;;;WAMA,qBACEC,aADF,EAE8B;AAAA;;AAAA;AAAA;;AAAA;;AAAA;AAAA;AAAA;AAAA;AACtBC,gBAAAA,YADsB,GACQ,EADR;AAAA;AAAA;AAAA;AAAA,yDAEID,aAFJ;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAEXE,gBAAAA,YAFW;AAG1BD,gBAAAA,YAAY,CAACE,IAAb,CAAkBD,YAAlB;AAH0B;AAI1B,uBAAMA,YAAN;;AAJ0B;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA,0DAMP,KAAI,CAACE,WAAL,CAAiBH,YAAjB,CANO;;AAAA;AAMtBI,gBAAAA,MANsB;AAAA;AAAA,0DAOT,KAAI,CAACC,IAAL,CAAUD,MAAV,CAPS;;AAAA;AAOtBC,gBAAAA,IAPsB;AAQ5B,iCAAA,KAAI,CAACT,OAAL,wFAAcU,MAAd,uGAAsBC,KAAtB,2GAA8B;AAACF,kBAAAA,IAAI,EAAJA;AAAD,iBAA9B;;AAR4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAS7B;;;;mFAID,kBAA4BN,aAA5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBACe,+CAA6BA,aAA7B,CADf;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O","sourcesContent":["// Hash\nimport {concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\ntype HashOptions = {\n  modules?: {[moduleName: string]: any};\n  crypto?: {\n    onEnd?: (result: {hash: string}) => any;\n  };\n};\n\n/** Abstract hash base class */\nexport abstract class Hash {\n  abstract readonly name: string;\n  abstract readonly options: HashOptions;\n\n  constructor(options: HashOptions = {}) {\n    this.hashBatches = this.hashBatches.bind(this);\n  }\n\n  async preload(): Promise<void> {\n    return;\n  }\n\n  abstract hash(arrayBuffer: ArrayBuffer): Promise<string>;\n\n  async *hashBatches(\n    asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n  ): AsyncIterable<ArrayBuffer> {\n    const arrayBuffers: ArrayBuffer[] = [];\n    for await (const arrayBuffer of asyncIterator) {\n      arrayBuffers.push(arrayBuffer);\n      yield arrayBuffer;\n    }\n    const output = await this.concatenate(arrayBuffers);\n    const hash = await this.hash(output);\n    this.options?.crypto?.onEnd?.({hash});\n  }\n\n  // HELPERS\n\n  protected async concatenate(asyncIterator): Promise<ArrayBuffer> {\n    return await concatenateArrayBuffersAsync(asyncIterator);\n  }\n}\n"],"file":"hash.js"}

package/dist/es5/lib/md5-hash.js

@@ -7,29 +7,87 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.MD5Hash = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _hash = require("./hash");
+var _hash2 = require("./hash");
 
 var _md5Wasm = _interopRequireDefault(require("./algorithms/md5-wasm"));
 
 var _digestUtils = require("./utils/digest-utils");
 
-class MD5Hash extends _hash.Hash {
-  constructor(options = {}) {
-    super();
-    (0, _defineProperty2.default)(this, "name", 'md5');
-    (0, _defineProperty2.default)(this, "options", void 0);
-    this.options = options;
-  }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
 
-  async hash(input) {
-    const md5Promise = new Promise((resolve, reject) => (0, _md5Wasm.default)(input).then(resolve).catch(reject));
-    const hex = await md5Promise;
-    return (0, _digestUtils.hexToBase64)(hex);
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var MD5Hash = function (_Hash) {
+  (0, _inherits2.default)(MD5Hash, _Hash);
+
+  var _super = _createSuper(MD5Hash);
+
+  function MD5Hash() {
+    var _this;
+
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2.default)(this, MD5Hash);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "name", 'md5');
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "options", void 0);
+    _this.options = options;
+    return _this;
   }
 
-}
+  (0, _createClass2.default)(MD5Hash, [{
+    key: "hash",
+    value: function () {
+      var _hash = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(input) {
+        var md5Promise, hex;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                md5Promise = new Promise(function (resolve, reject) {
+                  return (0, _md5Wasm.default)(input).then(resolve).catch(reject);
+                });
+                _context.next = 3;
+                return md5Promise;
+
+              case 3:
+                hex = _context.sent;
+                return _context.abrupt("return", (0, _digestUtils.hexToBase64)(hex));
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function hash(_x) {
+        return _hash.apply(this, arguments);
+      }
+
+      return hash;
+    }()
+  }]);
+  return MD5Hash;
+}(_hash2.Hash);
 
 exports.MD5Hash = MD5Hash;
 //# sourceMappingURL=md5-hash.js.map