@loaders.gl/crypto 3.0.13 → 3.0.14

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/md5-hash.ts"],"names":["MD5Hash","Hash","constructor","options","hash","input","md5Promise","Promise","resolve","reject","then","catch","hex"],"mappings":";;;;;;;;;;;AACA;;AACA;;AACA;;AAKO,MAAMA,OAAN,SAAsBC,UAAtB,CAA2B;AAIhCC,EAAAA,WAAW,CAACC,OAAO,GAAG,EAAX,EAAe;AACxB;AADwB,gDAHV,KAGU;AAAA;AAExB,SAAKA,OAAL,GAAeA,OAAf;AACD;;AAMS,QAAJC,IAAI,CAACC,KAAD,EAAsC;AAC9C,UAAMC,UAAU,GAAG,IAAIC,OAAJ,CAAoB,CAACC,OAAD,EAAUC,MAAV,KACrC,sBAAQJ,KAAR,EAAeK,IAAf,CAAoBF,OAApB,EAA6BG,KAA7B,CAAmCF,MAAnC,CADiB,CAAnB;AAGA,UAAMG,GAAG,GAAG,MAAMN,UAAlB;AACA,WAAO,8BAAYM,GAAZ,CAAP;AACD;;AAnB+B","sourcesContent":["// Fork of https://github.com/briantbutton/md5-wasm under MIT license\nimport {Hash} from './hash';\nimport md5WASM from './algorithms/md5-wasm';\nimport {hexToBase64} from './utils/digest-utils';\n\n/**\n * A transform that calculates MD5 hashes, passing data through\n */\nexport class MD5Hash extends Hash {\n  readonly name = 'md5';\n  readonly options;\n\n  constructor(options = {}) {\n    super();\n    this.options = options;\n  }\n\n  /**\n   * Atomic hash calculation\n   * @returns base64 encoded hash\n   */\n  async hash(input: ArrayBuffer): Promise<string> {\n    const md5Promise = new Promise<string>((resolve, reject) =>\n      md5WASM(input).then(resolve).catch(reject)\n    );\n    const hex = await md5Promise;\n    return hexToBase64(hex);\n  }\n}\n"],"file":"md5-hash.js"}
+{"version":3,"sources":["../../../src/lib/md5-hash.ts"],"names":["MD5Hash","options","input","md5Promise","Promise","resolve","reject","then","catch","hex","Hash"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AACA;;AACA;;;;;;IAKaA,O;;;;;AAIX,qBAA0B;AAAA;;AAAA,QAAdC,OAAc,uEAAJ,EAAI;AAAA;AACxB;AADwB,uFAHV,KAGU;AAAA;AAExB,UAAKA,OAAL,GAAeA,OAAf;AAFwB;AAGzB;;;;;4EAMD,iBAAWC,KAAX;AAAA;AAAA;AAAA;AAAA;AAAA;AACQC,gBAAAA,UADR,GACqB,IAAIC,OAAJ,CAAoB,UAACC,OAAD,EAAUC,MAAV;AAAA,yBACrC,sBAAQJ,KAAR,EAAeK,IAAf,CAAoBF,OAApB,EAA6BG,KAA7B,CAAmCF,MAAnC,CADqC;AAAA,iBAApB,CADrB;AAAA;AAAA,uBAIoBH,UAJpB;;AAAA;AAIQM,gBAAAA,GAJR;AAAA,iDAKS,8BAAYA,GAAZ,CALT;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O;;;;;;;;;;EAb2BC,W","sourcesContent":["// Fork of https://github.com/briantbutton/md5-wasm under MIT license\nimport {Hash} from './hash';\nimport md5WASM from './algorithms/md5-wasm';\nimport {hexToBase64} from './utils/digest-utils';\n\n/**\n * A transform that calculates MD5 hashes, passing data through\n */\nexport class MD5Hash extends Hash {\n  readonly name = 'md5';\n  readonly options;\n\n  constructor(options = {}) {\n    super();\n    this.options = options;\n  }\n\n  /**\n   * Atomic hash calculation\n   * @returns base64 encoded hash\n   */\n  async hash(input: ArrayBuffer): Promise<string> {\n    const md5Promise = new Promise<string>((resolve, reject) =>\n      md5WASM(input).then(resolve).catch(reject)\n    );\n    const hex = await md5Promise;\n    return hexToBase64(hex);\n  }\n}\n"],"file":"md5-hash.js"}

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

@@ -7,55 +7,203 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.NodeHash = 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");
 
 var _crypto = require("crypto");
 
-class NodeHash extends _hash.Hash {
-  constructor(options) {
-    var _this$options, _this$options$crypto;
+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); }; }
 
-    super();
-    (0, _defineProperty2.default)(this, "name", 'crypto-node');
-    (0, _defineProperty2.default)(this, "options", void 0);
-    (0, _defineProperty2.default)(this, "_algorithm", void 0);
-    (0, _defineProperty2.default)(this, "_hash", void 0);
-    this.options = options;
+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; } }
 
-    if (!((_this$options = this.options) !== null && _this$options !== void 0 && (_this$options$crypto = _this$options.crypto) !== null && _this$options$crypto !== void 0 && _this$options$crypto.algorithm)) {
-      throw new Error(this.name);
-    }
-  }
+var NodeHash = function (_Hash) {
+  (0, _inherits2.default)(NodeHash, _Hash);
 
-  async hash(input) {
-    var _this$options2, _this$options2$crypto, _this$options2$crypto2;
+  var _super = _createSuper(NodeHash);
 
-    await this.preload();
-    const hash = (0, _crypto.createHash)((_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.algorithm) === null || _this$options2$crypto2 === void 0 ? void 0 : _this$options2$crypto2.toLowerCase());
-    const inputArray = new Uint8Array(input);
-    return hash.update(inputArray).digest('base64');
-  }
+  function NodeHash(options) {
+    var _this2$options, _this2$options$crypto;
 
-  async *hashBatches(asyncIterator) {
-    var _this$options3, _this$options3$crypto, _this$options3$crypto2, _this$options4, _this$options4$crypto, _this$options4$crypto2;
+    var _this2;
 
-    await this.preload();
-    const hash = (0, _crypto.createHash)((_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.algorithm) === null || _this$options3$crypto2 === void 0 ? void 0 : _this$options3$crypto2.toLowerCase());
+    (0, _classCallCheck2.default)(this, NodeHash);
+    _this2 = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), "name", 'crypto-node');
+    (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;
 
-    for await (const chunk of asyncIterator) {
-      const inputArray = new Uint8Array(chunk);
-      hash.update(inputArray);
-      yield chunk;
+    if (!((_this2$options = _this2.options) !== null && _this2$options !== void 0 && (_this2$options$crypto = _this2$options.crypto) !== null && _this2$options$crypto !== void 0 && _this2$options$crypto.algorithm)) {
+      throw new Error(_this2.name);
     }
 
-    (_this$options4 = this.options) === null || _this$options4 === void 0 ? void 0 : (_this$options4$crypto = _this$options4.crypto) === null || _this$options4$crypto === void 0 ? void 0 : (_this$options4$crypto2 = _this$options4$crypto.onEnd) === null || _this$options4$crypto2 === void 0 ? void 0 : _this$options4$crypto2.call(_this$options4$crypto, {
-      hash: hash.digest('base64')
-    });
+    return _this2;
   }
 
-}
+  (0, _createClass2.default)(NodeHash, [{
+    key: "hash",
+    value: function () {
+      var _hash = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(input) {
+        var _this$options, _this$options$crypto, _this$options$crypto$;
+
+        var hash, inputArray;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this.preload();
+
+              case 2:
+                hash = (0, _crypto.createHash)((_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.algorithm) === null || _this$options$crypto$ === void 0 ? void 0 : _this$options$crypto$.toLowerCase());
+                inputArray = new Uint8Array(input);
+                return _context.abrupt("return", hash.update(inputArray).digest('base64'));
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function hash(_x) {
+        return _hash.apply(this, arguments);
+      }
+
+      return hash;
+    }()
+  }, {
+    key: "hashBatches",
+    value: function hashBatches(asyncIterator) {
+      var _this = this;
+
+      return (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee2() {
+        var _this$options2, _this$options2$crypto, _this$options2$crypto2, _this$options3, _this$options3$crypto, _this$options3$crypto2;
+
+        var hash, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, inputArray;
+
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return (0, _awaitAsyncGenerator2.default)(_this.preload());
+
+              case 2:
+                hash = (0, _crypto.createHash)((_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.algorithm) === null || _this$options2$crypto2 === void 0 ? void 0 : _this$options2$crypto2.toLowerCase());
+                _iteratorNormalCompletion = true;
+                _didIteratorError = false;
+                _context2.prev = 5;
+                _iterator = (0, _asyncIterator2.default)(asyncIterator);
+
+              case 7:
+                _context2.next = 9;
+                return (0, _awaitAsyncGenerator2.default)(_iterator.next());
+
+              case 9:
+                _step = _context2.sent;
+                _iteratorNormalCompletion = _step.done;
+                _context2.next = 13;
+                return (0, _awaitAsyncGenerator2.default)(_step.value);
+
+              case 13:
+                _value = _context2.sent;
+
+                if (_iteratorNormalCompletion) {
+                  _context2.next = 23;
+                  break;
+                }
+
+                chunk = _value;
+                inputArray = new Uint8Array(chunk);
+                hash.update(inputArray);
+                _context2.next = 20;
+                return chunk;
+
+              case 20:
+                _iteratorNormalCompletion = true;
+                _context2.next = 7;
+                break;
+
+              case 23:
+                _context2.next = 29;
+                break;
+
+              case 25:
+                _context2.prev = 25;
+                _context2.t0 = _context2["catch"](5);
+                _didIteratorError = true;
+                _iteratorError = _context2.t0;
+
+              case 29:
+                _context2.prev = 29;
+                _context2.prev = 30;
+
+                if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
+                  _context2.next = 34;
+                  break;
+                }
+
+                _context2.next = 34;
+                return (0, _awaitAsyncGenerator2.default)(_iterator.return());
+
+              case 34:
+                _context2.prev = 34;
+
+                if (!_didIteratorError) {
+                  _context2.next = 37;
+                  break;
+                }
+
+                throw _iteratorError;
+
+              case 37:
+                return _context2.finish(34);
+
+              case 38:
+                return _context2.finish(29);
+
+              case 39:
+                (_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: hash.digest('base64')
+                });
+
+              case 40:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, null, [[5, 25, 29, 39], [30,, 34, 38]]);
+      }))();
+    }
+  }]);
+  return NodeHash;
+}(_hash2.Hash);
 
 exports.NodeHash = NodeHash;
 //# sourceMappingURL=node-hash.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/node-hash.ts"],"names":["NodeHash","Hash","constructor","options","crypto","algorithm","Error","name","hash","input","preload","toLowerCase","inputArray","Uint8Array","update","digest","hashBatches","asyncIterator","chunk","onEnd"],"mappings":";;;;;;;;;;;AACA;;AACA;;AAaO,MAAMA,QAAN,SAAuBC,UAAvB,CAA4B;AASjCC,EAAAA,WAAW,CAACC,OAAD,EAA6B;AAAA;;AACtC;AADsC,gDARxB,aAQwB;AAAA;AAAA;AAAA;AAEtC,SAAKA,OAAL,GAAeA,OAAf;;AACA,QAAI,mBAAC,KAAKA,OAAN,kEAAC,cAAcC,MAAf,iDAAC,qBAAsBC,SAAvB,CAAJ,EAAsC;AACpC,YAAM,IAAIC,KAAJ,CAAU,KAAKC,IAAf,CAAN;AACD;AACF;;AAMS,QAAJC,IAAI,CAACC,KAAD,EAAsC;AAAA;;AAC9C,UAAM,KAAKC,OAAL,EAAN;AACA,UAAMF,IAAI,GAAG,0CAAW,KAAKL,OAAhB,4EAAW,eAAcC,MAAzB,oFAAW,sBAAsBC,SAAjC,2DAAW,uBAAiCM,WAAjC,EAAX,CAAb;AACA,UAAMC,UAAU,GAAG,IAAIC,UAAJ,CAAeJ,KAAf,CAAnB;AACA,WAAOD,IAAI,CAACM,MAAL,CAAYF,UAAZ,EAAwBG,MAAxB,CAA+B,QAA/B,CAAP;AACD;;AAEiB,SAAXC,WAAW,CAChBC,aADgB,EAEY;AAAA;;AAC5B,UAAM,KAAKP,OAAL,EAAN;AACA,UAAMF,IAAI,GAAG,0CAAW,KAAKL,OAAhB,4EAAW,eAAcC,MAAzB,oFAAW,sBAAsBC,SAAjC,2DAAW,uBAAiCM,WAAjC,EAAX,CAAb;;AACA,eAAW,MAAMO,KAAjB,IAA0BD,aAA1B,EAAyC;AAEvC,YAAML,UAAU,GAAG,IAAIC,UAAJ,CAAeK,KAAf,CAAnB;AACAV,MAAAA,IAAI,CAACM,MAAL,CAAYF,UAAZ;AACA,YAAMM,KAAN;AACD;;AACD,2BAAKf,OAAL,2FAAcC,MAAd,0GAAsBe,KAAtB,8GAA8B;AAACX,MAAAA,IAAI,EAAEA,IAAI,CAACO,MAAL,CAAY,QAAZ;AAAP,KAA9B;AACD;;AAxCgC","sourcesContent":["// This dependency is too big, application must provide it\nimport {Hash} from './hash';\nimport {createHash} from 'crypto'; // Node.js builtin\n\ntype CryptoHashOptions = {\n  crypto: {\n    algorithm: string;\n    onEnd?: (result: {hash: string}) => any;\n  };\n};\n\n/**\n * Calculates Cryptographic Hash using Node.js crypto library\n * @deprecated Warning, experimental class\n */\nexport class NodeHash extends Hash {\n  readonly name = 'crypto-node';\n\n  options: CryptoHashOptions;\n  // @ts-ignore\n  private _algorithm;\n  // @ts-ignore\n  private _hash;\n\n  constructor(options: CryptoHashOptions) {\n    super();\n    this.options = options;\n    if (!this.options?.crypto?.algorithm) {\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    const hash = createHash(this.options?.crypto?.algorithm?.toLowerCase());\n    const inputArray = new Uint8Array(input);\n    return hash.update(inputArray).digest('base64');\n  }\n\n  async *hashBatches(\n    asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n  ): AsyncIterable<ArrayBuffer> {\n    await this.preload();\n    const hash = createHash(this.options?.crypto?.algorithm?.toLowerCase());\n    for await (const chunk of asyncIterator) {\n      // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer\n      const inputArray = new Uint8Array(chunk);\n      hash.update(inputArray);\n      yield chunk;\n    }\n    this.options?.crypto?.onEnd?.({hash: hash.digest('base64')});\n  }\n}\n"],"file":"node-hash.js"}
+{"version":3,"sources":["../../../src/lib/node-hash.ts"],"names":["NodeHash","options","crypto","algorithm","Error","name","input","preload","hash","toLowerCase","inputArray","Uint8Array","update","digest","asyncIterator","chunk","onEnd","Hash"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AACA;;;;;;IAaaA,Q;;;;;AASX,oBAAYC,OAAZ,EAAwC;AAAA;;AAAA;;AAAA;AACtC;AADsC,wFARxB,aAQwB;AAAA;AAAA;AAAA;AAEtC,WAAKA,OAAL,GAAeA,OAAf;;AACA,QAAI,oBAAC,OAAKA,OAAN,oEAAC,eAAcC,MAAf,kDAAC,sBAAsBC,SAAvB,CAAJ,EAAsC;AACpC,YAAM,IAAIC,KAAJ,CAAU,OAAKC,IAAf,CAAN;AACD;;AALqC;AAMvC;;;;;4EAMD,iBAAWC,KAAX;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBACQ,KAAKC,OAAL,EADR;;AAAA;AAEQC,gBAAAA,IAFR,GAEe,yCAAW,KAAKP,OAAhB,0EAAW,cAAcC,MAAzB,kFAAW,qBAAsBC,SAAjC,0DAAW,sBAAiCM,WAAjC,EAAX,CAFf;AAGQC,gBAAAA,UAHR,GAGqB,IAAIC,UAAJ,CAAeL,KAAf,CAHrB;AAAA,iDAISE,IAAI,CAACI,MAAL,CAAYF,UAAZ,EAAwBG,MAAxB,CAA+B,QAA/B,CAJT;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O;;;;;;;;;;WAOA,qBACEC,aADF,EAE8B;AAAA;;AAAA;AAAA;;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0DACtB,KAAI,CAACP,OAAL,EADsB;;AAAA;AAEtBC,gBAAAA,IAFsB,GAEf,0CAAW,KAAI,CAACP,OAAhB,4EAAW,eAAcC,MAAzB,oFAAW,sBAAsBC,SAAjC,2DAAW,uBAAiCM,WAAjC,EAAX,CAFe;AAAA;AAAA;AAAA;AAAA,yDAGFK,aAHE;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAGXC,gBAAAA,KAHW;AAKpBL,gBAAAA,UALoB,GAKP,IAAIC,UAAJ,CAAeI,KAAf,CALO;AAM1BP,gBAAAA,IAAI,CAACI,MAAL,CAAYF,UAAZ;AAN0B;AAO1B,uBAAMK,KAAN;;AAP0B;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;AAS5B,kCAAA,KAAI,CAACd,OAAL,2FAAcC,MAAd,0GAAsBc,KAAtB,8GAA8B;AAACR,kBAAAA,IAAI,EAAEA,IAAI,CAACK,MAAL,CAAY,QAAZ;AAAP,iBAA9B;;AAT4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAU7B;;;EAxC2BI,W","sourcesContent":["// This dependency is too big, application must provide it\nimport {Hash} from './hash';\nimport {createHash} from 'crypto'; // Node.js builtin\n\ntype CryptoHashOptions = {\n  crypto: {\n    algorithm: string;\n    onEnd?: (result: {hash: string}) => any;\n  };\n};\n\n/**\n * Calculates Cryptographic Hash using Node.js crypto library\n * @deprecated Warning, experimental class\n */\nexport class NodeHash extends Hash {\n  readonly name = 'crypto-node';\n\n  options: CryptoHashOptions;\n  // @ts-ignore\n  private _algorithm;\n  // @ts-ignore\n  private _hash;\n\n  constructor(options: CryptoHashOptions) {\n    super();\n    this.options = options;\n    if (!this.options?.crypto?.algorithm) {\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    const hash = createHash(this.options?.crypto?.algorithm?.toLowerCase());\n    const inputArray = new Uint8Array(input);\n    return hash.update(inputArray).digest('base64');\n  }\n\n  async *hashBatches(\n    asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n  ): AsyncIterable<ArrayBuffer> {\n    await this.preload();\n    const hash = createHash(this.options?.crypto?.algorithm?.toLowerCase());\n    for await (const chunk of asyncIterator) {\n      // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer\n      const inputArray = new Uint8Array(chunk);\n      hash.update(inputArray);\n      yield chunk;\n    }\n    this.options?.crypto?.onEnd?.({hash: hash.digest('base64')});\n  }\n}\n"],"file":"node-hash.js"}

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

@@ -1,22 +1,48 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SHA256Hash = void 0;
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+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 _cryptoHash = require("./crypto-hash");
 
-class SHA256Hash extends _cryptoHash.CryptoHash {
-  constructor(options) {
-    super({ ...options,
-      crypto: { ...options.crypto,
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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; } }
+
+var SHA256Hash = function (_CryptoHash) {
+  (0, _inherits2.default)(SHA256Hash, _CryptoHash);
+
+  var _super = _createSuper(SHA256Hash);
+
+  function SHA256Hash(options) {
+    (0, _classCallCheck2.default)(this, SHA256Hash);
+    return _super.call(this, _objectSpread(_objectSpread({}, options), {}, {
+      crypto: _objectSpread(_objectSpread({}, options.crypto), {}, {
         algorithm: 'SHA256'
-      }
-    });
+      })
+    }));
   }
 
-}
+  return SHA256Hash;
+}(_cryptoHash.CryptoHash);
 
 exports.SHA256Hash = SHA256Hash;
 //# sourceMappingURL=sha256-hash.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/sha256-hash.ts"],"names":["SHA256Hash","CryptoHash","constructor","options","crypto","algorithm"],"mappings":";;;;;;;AACA;;AAYO,MAAMA,UAAN,SAAyBC,sBAAzB,CAAoC;AACzCC,EAAAA,WAAW,CAACC,OAAD,EAA6B;AACtC,UAAM,EAAC,GAAGA,OAAJ;AAAaC,MAAAA,MAAM,EAAE,EAAC,GAAGD,OAAO,CAACC,MAAZ;AAAoBC,QAAAA,SAAS,EAAE;AAA/B;AAArB,KAAN;AACD;;AAHwC","sourcesContent":["//\nimport {CryptoHash} from './crypto-hash';\n\ntype CryptoHashOptions = {\n  modules: {[moduleName: string]: any};\n  crypto?: {\n    onEnd?: (result: {hash: string}) => any;\n  };\n};\n\n/**\n * A transform that calculates Cryptographic Hash\n */\nexport class SHA256Hash extends CryptoHash {\n  constructor(options: CryptoHashOptions) {\n    super({...options, crypto: {...options.crypto, algorithm: 'SHA256'}});\n  }\n}\n"],"file":"sha256-hash.js"}
+{"version":3,"sources":["../../../src/lib/sha256-hash.ts"],"names":["SHA256Hash","options","crypto","algorithm","CryptoHash"],"mappings":";;;;;;;;;;;;;;;;;;;AACA;;;;;;;;;;IAYaA,U;;;;;AACX,sBAAYC,OAAZ,EAAwC;AAAA;AAAA,6DAC5BA,OAD4B;AACnBC,MAAAA,MAAM,kCAAMD,OAAO,CAACC,MAAd;AAAsBC,QAAAA,SAAS,EAAE;AAAjC;AADa;AAEvC;;;EAH6BC,sB","sourcesContent":["//\nimport {CryptoHash} from './crypto-hash';\n\ntype CryptoHashOptions = {\n  modules: {[moduleName: string]: any};\n  crypto?: {\n    onEnd?: (result: {hash: string}) => any;\n  };\n};\n\n/**\n * A transform that calculates Cryptographic Hash\n */\nexport class SHA256Hash extends CryptoHash {\n  constructor(options: CryptoHashOptions) {\n    super({...options, crypto: {...options.crypto, algorithm: 'SHA256'}});\n  }\n}\n"],"file":"sha256-hash.js"}

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

@@ -8,30 +8,30 @@ exports.toBase64 = toBase64;
 function toBase64(string) {
   string = "".concat(string);
 
-  for (let i = 0; i < string.length; i++) {
+  for (var i = 0; i < string.length; i++) {
     if (string.charCodeAt(i) > 255) {
       return null;
     }
   }
 
-  let out = '';
+  var out = '';
 
-  for (let i = 0; i < string.length; i += 3) {
-    const groupsOfSix = [undefined, undefined, undefined, undefined];
-    groupsOfSix[0] = string.charCodeAt(i) >> 2;
-    groupsOfSix[1] = (string.charCodeAt(i) & 0x03) << 4;
+  for (var _i = 0; _i < string.length; _i += 3) {
+    var groupsOfSix = [undefined, undefined, undefined, undefined];
+    groupsOfSix[0] = string.charCodeAt(_i) >> 2;
+    groupsOfSix[1] = (string.charCodeAt(_i) & 0x03) << 4;
 
-    if (string.length > i + 1) {
-      groupsOfSix[1] |= string.charCodeAt(i + 1) >> 4;
-      groupsOfSix[2] = (string.charCodeAt(i + 1) & 0x0f) << 2;
+    if (string.length > _i + 1) {
+      groupsOfSix[1] |= string.charCodeAt(_i + 1) >> 4;
+      groupsOfSix[2] = (string.charCodeAt(_i + 1) & 0x0f) << 2;
     }
 
-    if (string.length > i + 2) {
-      groupsOfSix[2] |= string.charCodeAt(i + 2) >> 6;
-      groupsOfSix[3] = string.charCodeAt(i + 2) & 0x3f;
+    if (string.length > _i + 2) {
+      groupsOfSix[2] |= string.charCodeAt(_i + 2) >> 6;
+      groupsOfSix[3] = string.charCodeAt(_i + 2) & 0x3f;
     }
 
-    for (let j = 0; j < groupsOfSix.length; j++) {
+    for (var j = 0; j < groupsOfSix.length; j++) {
       if (typeof groupsOfSix[j] === 'undefined') {
         out += '=';
       } else {

package/dist/es5/lib/utils/base64-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/utils/base64-utils.js"],"names":["toBase64","string","i","length","charCodeAt","out","groupsOfSix","undefined","j","btoaLookup","idx","String","fromCharCode"],"mappings":";;;;;;;AAIO,SAASA,QAAT,CAAkBC,MAAlB,EAA0B;AAE/BA,EAAAA,MAAM,aAAMA,MAAN,CAAN;;AAGA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGD,MAAM,CAACE,MAA3B,EAAmCD,CAAC,EAApC,EAAwC;AACtC,QAAID,MAAM,CAACG,UAAP,CAAkBF,CAAlB,IAAuB,GAA3B,EAAgC;AAC9B,aAAO,IAAP;AACD;AACF;;AACD,MAAIG,GAAG,GAAG,EAAV;;AACA,OAAK,IAAIH,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGD,MAAM,CAACE,MAA3B,EAAmCD,CAAC,IAAI,CAAxC,EAA2C;AAEzC,UAAMI,WAAW,GAAG,CAACC,SAAD,EAAYA,SAAZ,EAAuBA,SAAvB,EAAkCA,SAAlC,CAApB;AACAD,IAAAA,WAAW,CAAC,CAAD,CAAX,GAAiBL,MAAM,CAACG,UAAP,CAAkBF,CAAlB,KAAwB,CAAzC;AACAI,IAAAA,WAAW,CAAC,CAAD,CAAX,GAAiB,CAACL,MAAM,CAACG,UAAP,CAAkBF,CAAlB,IAAuB,IAAxB,KAAiC,CAAlD;;AACA,QAAID,MAAM,CAACE,MAAP,GAAgBD,CAAC,GAAG,CAAxB,EAA2B;AACzBI,MAAAA,WAAW,CAAC,CAAD,CAAX,IAAkBL,MAAM,CAACG,UAAP,CAAkBF,CAAC,GAAG,CAAtB,KAA4B,CAA9C;AACAI,MAAAA,WAAW,CAAC,CAAD,CAAX,GAAiB,CAACL,MAAM,CAACG,UAAP,CAAkBF,CAAC,GAAG,CAAtB,IAA2B,IAA5B,KAAqC,CAAtD;AACD;;AACD,QAAID,MAAM,CAACE,MAAP,GAAgBD,CAAC,GAAG,CAAxB,EAA2B;AACzBI,MAAAA,WAAW,CAAC,CAAD,CAAX,IAAkBL,MAAM,CAACG,UAAP,CAAkBF,CAAC,GAAG,CAAtB,KAA4B,CAA9C;AACAI,MAAAA,WAAW,CAAC,CAAD,CAAX,GAAiBL,MAAM,CAACG,UAAP,CAAkBF,CAAC,GAAG,CAAtB,IAA2B,IAA5C;AACD;;AACD,SAAK,IAAIM,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,WAAW,CAACH,MAAhC,EAAwCK,CAAC,EAAzC,EAA6C;AAC3C,UAAI,OAAOF,WAAW,CAACE,CAAD,CAAlB,KAA0B,WAA9B,EAA2C;AACzCH,QAAAA,GAAG,IAAI,GAAP;AACD,OAFD,MAEO;AACLA,QAAAA,GAAG,IAAII,UAAU,CAACH,WAAW,CAACE,CAAD,CAAZ,CAAjB;AACD;AACF;AACF;;AACD,SAAOH,GAAP;AACD;;AAMD,SAASI,UAAT,CAAoBC,GAApB,EAAyB;AACvB,MAAIA,GAAG,GAAG,EAAV,EAAc;AACZ,WAAOC,MAAM,CAACC,YAAP,CAAoBF,GAAG,GAAG,IAAIN,UAAJ,CAAe,CAAf,CAA1B,CAAP;AACD;;AACD,MAAIM,GAAG,GAAG,EAAV,EAAc;AACZ,WAAOC,MAAM,CAACC,YAAP,CAAoBF,GAAG,GAAG,EAAN,GAAW,IAAIN,UAAJ,CAAe,CAAf,CAA/B,CAAP;AACD;;AACD,MAAIM,GAAG,GAAG,EAAV,EAAc;AACZ,WAAOC,MAAM,CAACC,YAAP,CAAoBF,GAAG,GAAG,EAAN,GAAW,IAAIN,UAAJ,CAAe,CAAf,CAA/B,CAAP;AACD;;AACD,MAAIM,GAAG,KAAK,EAAZ,EAAgB;AACd,WAAO,GAAP;AACD;;AACD,MAAIA,GAAG,KAAK,EAAZ,EAAgB;AACd,WAAO,GAAP;AACD;;AAED,SAAOH,SAAP;AACD","sourcesContent":["/**\n * `btoa()` polyfill as defined by the HTML and Infra specs, which mostly just references\n * RFC 4648.\n */\nexport function toBase64(string) {\n  // String conversion as required by Web IDL.\n  string = `${string}`;\n  // \"The btoa() method must throw an \"InvalidCharacterError\" DOMException if\n  // data contains any character whose code point is greater than U+00FF.\"\n  for (let i = 0; i < string.length; i++) {\n    if (string.charCodeAt(i) > 255) {\n      return null;\n    }\n  }\n  let out = '';\n  for (let i = 0; i < string.length; i += 3) {\n    /** @type {Array[4]} */\n    const groupsOfSix = [undefined, undefined, undefined, undefined];\n    groupsOfSix[0] = string.charCodeAt(i) >> 2;\n    groupsOfSix[1] = (string.charCodeAt(i) & 0x03) << 4;\n    if (string.length > i + 1) {\n      groupsOfSix[1] |= string.charCodeAt(i + 1) >> 4;\n      groupsOfSix[2] = (string.charCodeAt(i + 1) & 0x0f) << 2;\n    }\n    if (string.length > i + 2) {\n      groupsOfSix[2] |= string.charCodeAt(i + 2) >> 6;\n      groupsOfSix[3] = string.charCodeAt(i + 2) & 0x3f;\n    }\n    for (let j = 0; j < groupsOfSix.length; j++) {\n      if (typeof groupsOfSix[j] === 'undefined') {\n        out += '=';\n      } else {\n        out += btoaLookup(groupsOfSix[j]);\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * Lookup table for btoa(), which converts a six-bit number into the\n * corresponding ASCII character.\n */\nfunction btoaLookup(idx) {\n  if (idx < 26) {\n    return String.fromCharCode(idx + 'A'.charCodeAt(0));\n  }\n  if (idx < 52) {\n    return String.fromCharCode(idx - 26 + 'a'.charCodeAt(0));\n  }\n  if (idx < 62) {\n    return String.fromCharCode(idx - 52 + '0'.charCodeAt(0));\n  }\n  if (idx === 62) {\n    return '+';\n  }\n  if (idx === 63) {\n    return '/';\n  }\n  // Throw INVALID_CHARACTER_ERR exception here -- won't be hit in the teststring.\n  return undefined;\n}\n"],"file":"base64-utils.js"}
+{"version":3,"sources":["../../../../src/lib/utils/base64-utils.js"],"names":["toBase64","string","i","length","charCodeAt","out","groupsOfSix","undefined","j","btoaLookup","idx","String","fromCharCode"],"mappings":";;;;;;;AAIO,SAASA,QAAT,CAAkBC,MAAlB,EAA0B;AAE/BA,EAAAA,MAAM,aAAMA,MAAN,CAAN;;AAGA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGD,MAAM,CAACE,MAA3B,EAAmCD,CAAC,EAApC,EAAwC;AACtC,QAAID,MAAM,CAACG,UAAP,CAAkBF,CAAlB,IAAuB,GAA3B,EAAgC;AAC9B,aAAO,IAAP;AACD;AACF;;AACD,MAAIG,GAAG,GAAG,EAAV;;AACA,OAAK,IAAIH,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAGD,MAAM,CAACE,MAA3B,EAAmCD,EAAC,IAAI,CAAxC,EAA2C;AAEzC,QAAMI,WAAW,GAAG,CAACC,SAAD,EAAYA,SAAZ,EAAuBA,SAAvB,EAAkCA,SAAlC,CAApB;AACAD,IAAAA,WAAW,CAAC,CAAD,CAAX,GAAiBL,MAAM,CAACG,UAAP,CAAkBF,EAAlB,KAAwB,CAAzC;AACAI,IAAAA,WAAW,CAAC,CAAD,CAAX,GAAiB,CAACL,MAAM,CAACG,UAAP,CAAkBF,EAAlB,IAAuB,IAAxB,KAAiC,CAAlD;;AACA,QAAID,MAAM,CAACE,MAAP,GAAgBD,EAAC,GAAG,CAAxB,EAA2B;AACzBI,MAAAA,WAAW,CAAC,CAAD,CAAX,IAAkBL,MAAM,CAACG,UAAP,CAAkBF,EAAC,GAAG,CAAtB,KAA4B,CAA9C;AACAI,MAAAA,WAAW,CAAC,CAAD,CAAX,GAAiB,CAACL,MAAM,CAACG,UAAP,CAAkBF,EAAC,GAAG,CAAtB,IAA2B,IAA5B,KAAqC,CAAtD;AACD;;AACD,QAAID,MAAM,CAACE,MAAP,GAAgBD,EAAC,GAAG,CAAxB,EAA2B;AACzBI,MAAAA,WAAW,CAAC,CAAD,CAAX,IAAkBL,MAAM,CAACG,UAAP,CAAkBF,EAAC,GAAG,CAAtB,KAA4B,CAA9C;AACAI,MAAAA,WAAW,CAAC,CAAD,CAAX,GAAiBL,MAAM,CAACG,UAAP,CAAkBF,EAAC,GAAG,CAAtB,IAA2B,IAA5C;AACD;;AACD,SAAK,IAAIM,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,WAAW,CAACH,MAAhC,EAAwCK,CAAC,EAAzC,EAA6C;AAC3C,UAAI,OAAOF,WAAW,CAACE,CAAD,CAAlB,KAA0B,WAA9B,EAA2C;AACzCH,QAAAA,GAAG,IAAI,GAAP;AACD,OAFD,MAEO;AACLA,QAAAA,GAAG,IAAII,UAAU,CAACH,WAAW,CAACE,CAAD,CAAZ,CAAjB;AACD;AACF;AACF;;AACD,SAAOH,GAAP;AACD;;AAMD,SAASI,UAAT,CAAoBC,GAApB,EAAyB;AACvB,MAAIA,GAAG,GAAG,EAAV,EAAc;AACZ,WAAOC,MAAM,CAACC,YAAP,CAAoBF,GAAG,GAAG,IAAIN,UAAJ,CAAe,CAAf,CAA1B,CAAP;AACD;;AACD,MAAIM,GAAG,GAAG,EAAV,EAAc;AACZ,WAAOC,MAAM,CAACC,YAAP,CAAoBF,GAAG,GAAG,EAAN,GAAW,IAAIN,UAAJ,CAAe,CAAf,CAA/B,CAAP;AACD;;AACD,MAAIM,GAAG,GAAG,EAAV,EAAc;AACZ,WAAOC,MAAM,CAACC,YAAP,CAAoBF,GAAG,GAAG,EAAN,GAAW,IAAIN,UAAJ,CAAe,CAAf,CAA/B,CAAP;AACD;;AACD,MAAIM,GAAG,KAAK,EAAZ,EAAgB;AACd,WAAO,GAAP;AACD;;AACD,MAAIA,GAAG,KAAK,EAAZ,EAAgB;AACd,WAAO,GAAP;AACD;;AAED,SAAOH,SAAP;AACD","sourcesContent":["/**\n * `btoa()` polyfill as defined by the HTML and Infra specs, which mostly just references\n * RFC 4648.\n */\nexport function toBase64(string) {\n  // String conversion as required by Web IDL.\n  string = `${string}`;\n  // \"The btoa() method must throw an \"InvalidCharacterError\" DOMException if\n  // data contains any character whose code point is greater than U+00FF.\"\n  for (let i = 0; i < string.length; i++) {\n    if (string.charCodeAt(i) > 255) {\n      return null;\n    }\n  }\n  let out = '';\n  for (let i = 0; i < string.length; i += 3) {\n    /** @type {Array[4]} */\n    const groupsOfSix = [undefined, undefined, undefined, undefined];\n    groupsOfSix[0] = string.charCodeAt(i) >> 2;\n    groupsOfSix[1] = (string.charCodeAt(i) & 0x03) << 4;\n    if (string.length > i + 1) {\n      groupsOfSix[1] |= string.charCodeAt(i + 1) >> 4;\n      groupsOfSix[2] = (string.charCodeAt(i + 1) & 0x0f) << 2;\n    }\n    if (string.length > i + 2) {\n      groupsOfSix[2] |= string.charCodeAt(i + 2) >> 6;\n      groupsOfSix[3] = string.charCodeAt(i + 2) & 0x3f;\n    }\n    for (let j = 0; j < groupsOfSix.length; j++) {\n      if (typeof groupsOfSix[j] === 'undefined') {\n        out += '=';\n      } else {\n        out += btoaLookup(groupsOfSix[j]);\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * Lookup table for btoa(), which converts a six-bit number into the\n * corresponding ASCII character.\n */\nfunction btoaLookup(idx) {\n  if (idx < 26) {\n    return String.fromCharCode(idx + 'A'.charCodeAt(0));\n  }\n  if (idx < 52) {\n    return String.fromCharCode(idx - 26 + 'a'.charCodeAt(0));\n  }\n  if (idx < 62) {\n    return String.fromCharCode(idx - 52 + '0'.charCodeAt(0));\n  }\n  if (idx === 62) {\n    return '+';\n  }\n  if (idx === 63) {\n    return '/';\n  }\n  // Throw INVALID_CHARACTER_ERR exception here -- won't be hit in the teststring.\n  return undefined;\n}\n"],"file":"base64-utils.js"}

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

@@ -9,7 +9,7 @@ exports.hexToBase64 = hexToBase64;
 var _base64Utils = require("./base64-utils");
 
 function toHex(cipher) {
-  const hexString = cipher.toString(16);
+  var hexString = cipher.toString(16);
   return hexString === '0' ? "0".concat(hexString) : hexString;
 }
 
@@ -18,7 +18,9 @@ function hexToBase64(hexstring) {
     hexstring = "0".concat(hexstring);
   }
 
-  const string = hexstring.match(/\w{2}/g).map(a => String.fromCharCode(parseInt(a, 16))).join('');
+  var string = hexstring.match(/\w{2}/g).map(function (a) {
+    return String.fromCharCode(parseInt(a, 16));
+  }).join('');
   return (0, _base64Utils.toBase64)(string);
 }
 //# sourceMappingURL=digest-utils.js.map

package/dist/es5/lib/utils/digest-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/utils/digest-utils.js"],"names":["toHex","cipher","hexString","toString","hexToBase64","hexstring","length","string","match","map","a","String","fromCharCode","parseInt","join"],"mappings":";;;;;;;;AAAA;;AAKO,SAASA,KAAT,CAAeC,MAAf,EAAuB;AAC5B,QAAMC,SAAS,GAAGD,MAAM,CAACE,QAAP,CAAgB,EAAhB,CAAlB;AACA,SAAOD,SAAS,KAAK,GAAd,cAAwBA,SAAxB,IAAsCA,SAA7C;AACD;;AAKM,SAASE,WAAT,CAAqBC,SAArB,EAAgC;AAGrC,MAAIA,SAAS,CAACC,MAAV,GAAmB,CAAnB,KAAyB,CAA7B,EAAgC;AAC9BD,IAAAA,SAAS,cAAOA,SAAP,CAAT;AACD;;AACD,QAAME,MAAM,GAAGF,SAAS,CACrBG,KADY,CACN,QADM,EAEZC,GAFY,CAEPC,CAAD,IAAOC,MAAM,CAACC,YAAP,CAAoBC,QAAQ,CAACH,CAAD,EAAI,EAAJ,CAA5B,CAFC,EAGZI,IAHY,CAGP,EAHO,CAAf;AAIA,SAAO,2BAASP,MAAT,CAAP;AACD","sourcesContent":["import {toBase64} from './base64-utils';\n\n/**\n *\n */\nexport function toHex(cipher) {\n  const hexString = cipher.toString(16);\n  return hexString === '0' ? `0${hexString}` : hexString;\n}\n\n/**\n *\n */\nexport function hexToBase64(hexstring) {\n  // Add leading zero to keep even count of digits\n  // eg. f85d741 => 0f85d741\n  if (hexstring.length % 2 !== 0) {\n    hexstring = `0${hexstring}`;\n  }\n  const string = hexstring\n    .match(/\\w{2}/g)\n    .map((a) => String.fromCharCode(parseInt(a, 16)))\n    .join('');\n  return toBase64(string);\n}\n"],"file":"digest-utils.js"}
+{"version":3,"sources":["../../../../src/lib/utils/digest-utils.js"],"names":["toHex","cipher","hexString","toString","hexToBase64","hexstring","length","string","match","map","a","String","fromCharCode","parseInt","join"],"mappings":";;;;;;;;AAAA;;AAKO,SAASA,KAAT,CAAeC,MAAf,EAAuB;AAC5B,MAAMC,SAAS,GAAGD,MAAM,CAACE,QAAP,CAAgB,EAAhB,CAAlB;AACA,SAAOD,SAAS,KAAK,GAAd,cAAwBA,SAAxB,IAAsCA,SAA7C;AACD;;AAKM,SAASE,WAAT,CAAqBC,SAArB,EAAgC;AAGrC,MAAIA,SAAS,CAACC,MAAV,GAAmB,CAAnB,KAAyB,CAA7B,EAAgC;AAC9BD,IAAAA,SAAS,cAAOA,SAAP,CAAT;AACD;;AACD,MAAME,MAAM,GAAGF,SAAS,CACrBG,KADY,CACN,QADM,EAEZC,GAFY,CAER,UAACC,CAAD;AAAA,WAAOC,MAAM,CAACC,YAAP,CAAoBC,QAAQ,CAACH,CAAD,EAAI,EAAJ,CAA5B,CAAP;AAAA,GAFQ,EAGZI,IAHY,CAGP,EAHO,CAAf;AAIA,SAAO,2BAASP,MAAT,CAAP;AACD","sourcesContent":["import {toBase64} from './base64-utils';\n\n/**\n *\n */\nexport function toHex(cipher) {\n  const hexString = cipher.toString(16);\n  return hexString === '0' ? `0${hexString}` : hexString;\n}\n\n/**\n *\n */\nexport function hexToBase64(hexstring) {\n  // Add leading zero to keep even count of digits\n  // eg. f85d741 => 0f85d741\n  if (hexstring.length % 2 !== 0) {\n    hexstring = `0${hexstring}`;\n  }\n  const string = hexstring\n    .match(/\\w{2}/g)\n    .map((a) => String.fromCharCode(parseInt(a, 16)))\n    .join('');\n  return toBase64(string);\n}\n"],"file":"digest-utils.js"}

package/dist/es5/workers/worker.js

@@ -1,21 +1,27 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "CRC32Hash", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _crc32Hash.CRC32Hash;
   }
 });
 Object.defineProperty(exports, "CRC32CHash", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _crc32cHash.CRC32CHash;
   }
 });
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _workerUtils = require("@loaders.gl/worker-utils");
 
 var _crc32Hash = require("../lib/crc32-hash");
@@ -24,23 +30,55 @@ var _crc32cHash = require("../lib/crc32c-hash");
 
 var _md5Hash = require("../lib/md5-hash");
 
-(0, _workerUtils.createWorker)(async (data, options = {}) => {
-  const {
-    operation
-  } = options;
+(0, _workerUtils.createWorker)(function () {
+  var _ref = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(data) {
+    var options,
+        operation,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+            operation = options.operation;
+            _context.t0 = operation;
+            _context.next = _context.t0 === 'crc32' ? 5 : _context.t0 === 'crc32c' ? 8 : _context.t0 === 'md5' ? 11 : 14;
+            break;
 
-  switch (operation) {
-    case 'crc32':
-      return await new _crc32Hash.CRC32Hash(options).hash(data);
+          case 5:
+            _context.next = 7;
+            return new _crc32Hash.CRC32Hash(options).hash(data);
 
-    case 'crc32c':
-      return await new _crc32cHash.CRC32CHash(options).hash(data);
+          case 7:
+            return _context.abrupt("return", _context.sent);
 
-    case 'md5':
-      return await new _md5Hash.MD5Hash(options).hash(data);
+          case 8:
+            _context.next = 10;
+            return new _crc32cHash.CRC32CHash(options).hash(data);
 
-    default:
-      throw new Error("invalid option: ".concat(operation));
-  }
-});
+          case 10:
+            return _context.abrupt("return", _context.sent);
+
+          case 11:
+            _context.next = 13;
+            return new _md5Hash.MD5Hash(options).hash(data);
+
+          case 13:
+            return _context.abrupt("return", _context.sent);
+
+          case 14:
+            throw new Error("invalid option: ".concat(operation));
+
+          case 15:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function (_x) {
+    return _ref.apply(this, arguments);
+  };
+}());
 //# sourceMappingURL=worker.js.map

package/dist/es5/workers/worker.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/workers/worker.ts"],"names":["data","options","operation","CRC32Hash","hash","CRC32CHash","MD5Hash","Error"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AAKA,+BAAa,OAAOA,IAAP,EAAaC,OAAO,GAAG,EAAvB,KAA8B;AAEzC,QAAM;AAACC,IAAAA;AAAD,MAAcD,OAApB;;AAEA,UAAQC,SAAR;AACE,SAAK,OAAL;AACE,aAAO,MAAM,IAAIC,oBAAJ,CAAcF,OAAd,EAAuBG,IAAvB,CAA4BJ,IAA5B,CAAb;;AACF,SAAK,QAAL;AACE,aAAO,MAAM,IAAIK,sBAAJ,CAAeJ,OAAf,EAAwBG,IAAxB,CAA6BJ,IAA7B,CAAb;;AACF,SAAK,KAAL;AACE,aAAO,MAAM,IAAIM,gBAAJ,CAAYL,OAAZ,EAAqBG,IAArB,CAA0BJ,IAA1B,CAAb;;AACF;AACE,YAAM,IAAIO,KAAJ,2BAA6BL,SAA7B,EAAN;AARJ;AAUD,CAdD","sourcesContent":["import {createWorker} from '@loaders.gl/worker-utils';\nimport {CRC32Hash} from '../lib/crc32-hash';\nimport {CRC32CHash} from '../lib/crc32c-hash';\nimport {MD5Hash} from '../lib/md5-hash';\n\n// Assuming we can bundle as module\nexport {CRC32Hash, CRC32CHash};\n\ncreateWorker(async (data, options = {}) => {\n  // @ts-ignore\n  const {operation} = options;\n\n  switch (operation) {\n    case 'crc32':\n      return await new CRC32Hash(options).hash(data);\n    case 'crc32c':\n      return await new CRC32CHash(options).hash(data);\n    case 'md5':\n      return await new MD5Hash(options).hash(data);\n    default:\n      throw new Error(`invalid option: ${operation}`);\n  }\n});\n"],"file":"worker.js"}
+{"version":3,"sources":["../../../src/workers/worker.ts"],"names":["data","options","operation","CRC32Hash","hash","CRC32CHash","MD5Hash","Error"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AAKA;AAAA,uEAAa,iBAAOA,IAAP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAaC,YAAAA,OAAb,2DAAuB,EAAvB;AAEJC,YAAAA,SAFI,GAESD,OAFT,CAEJC,SAFI;AAAA,0BAIHA,SAJG;AAAA,4CAKJ,OALI,uBAOJ,QAPI,uBASJ,KATI;AAAA;;AAAA;AAAA;AAAA,mBAMM,IAAIC,oBAAJ,CAAcF,OAAd,EAAuBG,IAAvB,CAA4BJ,IAA5B,CANN;;AAAA;AAAA;;AAAA;AAAA;AAAA,mBAQM,IAAIK,sBAAJ,CAAeJ,OAAf,EAAwBG,IAAxB,CAA6BJ,IAA7B,CARN;;AAAA;AAAA;;AAAA;AAAA;AAAA,mBAUM,IAAIM,gBAAJ,CAAYL,OAAZ,EAAqBG,IAArB,CAA0BJ,IAA1B,CAVN;;AAAA;AAAA;;AAAA;AAAA,kBAYD,IAAIO,KAAJ,2BAA6BL,SAA7B,EAZC;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAAb;;AAAA;AAAA;AAAA;AAAA","sourcesContent":["import {createWorker} from '@loaders.gl/worker-utils';\nimport {CRC32Hash} from '../lib/crc32-hash';\nimport {CRC32CHash} from '../lib/crc32c-hash';\nimport {MD5Hash} from '../lib/md5-hash';\n\n// Assuming we can bundle as module\nexport {CRC32Hash, CRC32CHash};\n\ncreateWorker(async (data, options = {}) => {\n  // @ts-ignore\n  const {operation} = options;\n\n  switch (operation) {\n    case 'crc32':\n      return await new CRC32Hash(options).hash(data);\n    case 'crc32c':\n      return await new CRC32CHash(options).hash(data);\n    case 'md5':\n      return await new MD5Hash(options).hash(data);\n    default:\n      throw new Error(`invalid option: ${operation}`);\n  }\n});\n"],"file":"worker.js"}

package/dist/esm/index.js

@@ -5,7 +5,7 @@ export { SHA256Hash } from './lib/sha256-hash';
 export { CryptoHash } from './lib/crypto-hash';
 export { NodeHash } from './lib/node-hash';
 export { hexToBase64 as _hexToBase64, toHex as _toHex } from './lib/utils/digest-utils';
-const VERSION = typeof "3.0.13" !== 'undefined' ? "3.0.13" : 'latest';
+const VERSION = typeof "3.0.14" !== 'undefined' ? "3.0.14" : 'latest';
 export const CryptoWorker = {
   id: 'crypto',
   name: 'CRC32, CRC32c and MD5 Hashes',