@loaders.gl/polyfills 3.0.13 → 3.0.14

package/dist/es5/node/file/blob-stream-controller.js

@@ -7,59 +7,104 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.BlobStreamController = 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"));
 
-class BlobStreamController {
-  constructor(chunks) {
+var BlobStreamController = function () {
+  function BlobStreamController(chunks) {
+    (0, _classCallCheck2.default)(this, BlobStreamController);
     (0, _defineProperty2.default)(this, "chunks", void 0);
     (0, _defineProperty2.default)(this, "isWorking", false);
     (0, _defineProperty2.default)(this, "isCancelled", false);
     this.chunks = chunks;
   }
 
-  start(controller) {
-    this.work(controller);
-  }
+  (0, _createClass2.default)(BlobStreamController, [{
+    key: "start",
+    value: function start(controller) {
+      this.work(controller);
+    }
+  }, {
+    key: "work",
+    value: function () {
+      var _work = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(controller) {
+        var chunks, next;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                chunks = this.chunks;
+                this.isWorking = true;
 
-  async work(controller) {
-    const {
-      chunks
-    } = this;
-    this.isWorking = true;
+              case 2:
+                if (!(!this.isCancelled && (controller.desiredSize || 0) > 0)) {
+                  _context.next = 15;
+                  break;
+                }
 
-    while (!this.isCancelled && (controller.desiredSize || 0) > 0) {
-      let next;
+                next = void 0;
+                _context.prev = 4;
+                next = chunks.next();
+                _context.next = 12;
+                break;
 
-      try {
-        next = chunks.next();
-      } catch (error) {
-        controller.error(error);
-        break;
-      }
+              case 8:
+                _context.prev = 8;
+                _context.t0 = _context["catch"](4);
+                controller.error(_context.t0);
+                return _context.abrupt("break", 15);
 
-      if (next) {
-        if (!next.done && !this.isCancelled) {
-          controller.enqueue(next.value);
-        } else {
-          controller.close();
-        }
-      }
-    }
+              case 12:
+                if (next) {
+                  if (!next.done && !this.isCancelled) {
+                    controller.enqueue(next.value);
+                  } else {
+                    controller.close();
+                  }
+                }
 
-    this.isWorking = false;
-  }
+                _context.next = 2;
+                break;
 
-  pull(controller) {
-    if (!this.isWorking) {
-      this.work(controller);
-    }
-  }
+              case 15:
+                this.isWorking = false;
 
-  cancel() {
-    this.isCancelled = true;
-  }
+              case 16:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[4, 8]]);
+      }));
 
-}
+      function work(_x) {
+        return _work.apply(this, arguments);
+      }
+
+      return work;
+    }()
+  }, {
+    key: "pull",
+    value: function pull(controller) {
+      if (!this.isWorking) {
+        this.work(controller);
+      }
+    }
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      this.isCancelled = true;
+    }
+  }]);
+  return BlobStreamController;
+}();
 
 exports.BlobStreamController = BlobStreamController;
 //# sourceMappingURL=blob-stream-controller.js.map

package/dist/es5/node/file/blob-stream-controller.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/node/file/blob-stream-controller.ts"],"names":["BlobStreamController","constructor","chunks","start","controller","work","isWorking","isCancelled","desiredSize","next","error","done","enqueue","value","close","pull","cancel"],"mappings":";;;;;;;;;;;AAIO,MAAMA,oBAAN,CAA2B;AAQhCC,EAAAA,WAAW,CAACC,MAAD,EAA+B;AAAA;AAAA,qDANb,KAMa;AAAA,uDALX,KAKW;AACxC,SAAKA,MAAL,GAAcA,MAAd;AACD;;AAKDC,EAAAA,KAAK,CAACC,UAAD,EAA8C;AACjD,SAAKC,IAAL,CAAUD,UAAV;AACD;;AAMS,QAAJC,IAAI,CAACD,UAAD,EAA8C;AACtD,UAAM;AAACF,MAAAA;AAAD,QAAW,IAAjB;AAEA,SAAKI,SAAL,GAAiB,IAAjB;;AACA,WAAO,CAAC,KAAKC,WAAN,IAAqB,CAACH,UAAU,CAACI,WAAX,IAA0B,CAA3B,IAAgC,CAA5D,EAA+D;AAC7D,UAAIC,IAAJ;;AACA,UAAI;AACFA,QAAAA,IAAI,GAAGP,MAAM,CAACO,IAAP,EAAP;AACD,OAFD,CAEE,OAAOC,KAAP,EAAc;AACdN,QAAAA,UAAU,CAACM,KAAX,CAAiBA,KAAjB;AACA;AACD;;AAED,UAAID,IAAJ,EAAU;AACR,YAAI,CAACA,IAAI,CAACE,IAAN,IAAc,CAAC,KAAKJ,WAAxB,EAAqC;AACnCH,UAAAA,UAAU,CAACQ,OAAX,CAAmBH,IAAI,CAACI,KAAxB;AACD,SAFD,MAEO;AACLT,UAAAA,UAAU,CAACU,KAAX;AACD;AACF;AACF;;AAED,SAAKR,SAAL,GAAiB,KAAjB;AACD;;AAMDS,EAAAA,IAAI,CAACX,UAAD,EAAa;AACf,QAAI,CAAC,KAAKE,SAAV,EAAqB;AACnB,WAAKD,IAAL,CAAUD,UAAV;AACD;AACF;;AACDY,EAAAA,MAAM,GAAG;AACP,SAAKT,WAAL,GAAmB,IAAnB;AACD;;AA3D+B","sourcesContent":["/**\n * Forked from @gozala's web-blob under MIT license\n * @see https://github.com/Gozala/web-blob\n */\nexport class BlobStreamController {\n  private chunks: Iterator<Uint8Array>;\n  private isWorking: boolean = false;\n  private isCancelled: boolean = false;\n\n  /**\n   * @param chunks\n   */\n  constructor(chunks: Iterator<Uint8Array>) {\n    this.chunks = chunks;\n  }\n\n  /**\n   * @param controller\n   */\n  start(controller: ReadableStreamDefaultController) {\n    this.work(controller); // eslint-disable-line @typescript-eslint/no-floating-promises\n  }\n\n  /**\n   *\n   * @param controller\n   */\n  async work(controller: ReadableStreamDefaultController) {\n    const {chunks} = this;\n\n    this.isWorking = true;\n    while (!this.isCancelled && (controller.desiredSize || 0) > 0) {\n      let next: {done?: boolean; value?: Uint8Array} | undefined;\n      try {\n        next = chunks.next();\n      } catch (error) {\n        controller.error(error);\n        break;\n      }\n\n      if (next) {\n        if (!next.done && !this.isCancelled) {\n          controller.enqueue(next.value);\n        } else {\n          controller.close();\n        }\n      }\n    }\n\n    this.isWorking = false;\n  }\n\n  /**\n   *\n   * @param {ReadableStreamDefaultController} controller\n   */\n  pull(controller) {\n    if (!this.isWorking) {\n      this.work(controller); // eslint-disable-line @typescript-eslint/no-floating-promises\n    }\n  }\n  cancel() {\n    this.isCancelled = true;\n  }\n}\n"],"file":"blob-stream-controller.js"}
+{"version":3,"sources":["../../../../src/node/file/blob-stream-controller.ts"],"names":["BlobStreamController","chunks","controller","work","isWorking","isCancelled","desiredSize","next","error","done","enqueue","value","close"],"mappings":";;;;;;;;;;;;;;;;;;;IAIaA,oB;AAQX,gCAAYC,MAAZ,EAA0C;AAAA;AAAA;AAAA,qDANb,KAMa;AAAA,uDALX,KAKW;AACxC,SAAKA,MAAL,GAAcA,MAAd;AACD;;;;WAKD,eAAMC,UAAN,EAAmD;AACjD,WAAKC,IAAL,CAAUD,UAAV;AACD;;;;4EAMD,iBAAWA,UAAX;AAAA;AAAA;AAAA;AAAA;AAAA;AACSD,gBAAAA,MADT,GACmB,IADnB,CACSA,MADT;AAGE,qBAAKG,SAAL,GAAiB,IAAjB;;AAHF;AAAA,sBAIS,CAAC,KAAKC,WAAN,IAAqB,CAACH,UAAU,CAACI,WAAX,IAA0B,CAA3B,IAAgC,CAJ9D;AAAA;AAAA;AAAA;;AAKQC,gBAAAA,IALR;AAAA;AAOMA,gBAAAA,IAAI,GAAGN,MAAM,CAACM,IAAP,EAAP;AAPN;AAAA;;AAAA;AAAA;AAAA;AASML,gBAAAA,UAAU,CAACM,KAAX;AATN;;AAAA;AAaI,oBAAID,IAAJ,EAAU;AACR,sBAAI,CAACA,IAAI,CAACE,IAAN,IAAc,CAAC,KAAKJ,WAAxB,EAAqC;AACnCH,oBAAAA,UAAU,CAACQ,OAAX,CAAmBH,IAAI,CAACI,KAAxB;AACD,mBAFD,MAEO;AACLT,oBAAAA,UAAU,CAACU,KAAX;AACD;AACF;;AAnBL;AAAA;;AAAA;AAsBE,qBAAKR,SAAL,GAAiB,KAAjB;;AAtBF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,O;;;;;;;;;;WA6BA,cAAKF,UAAL,EAAiB;AACf,UAAI,CAAC,KAAKE,SAAV,EAAqB;AACnB,aAAKD,IAAL,CAAUD,UAAV;AACD;AACF;;;WACD,kBAAS;AACP,WAAKG,WAAL,GAAmB,IAAnB;AACD","sourcesContent":["/**\n * Forked from @gozala's web-blob under MIT license\n * @see https://github.com/Gozala/web-blob\n */\nexport class BlobStreamController {\n  private chunks: Iterator<Uint8Array>;\n  private isWorking: boolean = false;\n  private isCancelled: boolean = false;\n\n  /**\n   * @param chunks\n   */\n  constructor(chunks: Iterator<Uint8Array>) {\n    this.chunks = chunks;\n  }\n\n  /**\n   * @param controller\n   */\n  start(controller: ReadableStreamDefaultController) {\n    this.work(controller); // eslint-disable-line @typescript-eslint/no-floating-promises\n  }\n\n  /**\n   *\n   * @param controller\n   */\n  async work(controller: ReadableStreamDefaultController) {\n    const {chunks} = this;\n\n    this.isWorking = true;\n    while (!this.isCancelled && (controller.desiredSize || 0) > 0) {\n      let next: {done?: boolean; value?: Uint8Array} | undefined;\n      try {\n        next = chunks.next();\n      } catch (error) {\n        controller.error(error);\n        break;\n      }\n\n      if (next) {\n        if (!next.done && !this.isCancelled) {\n          controller.enqueue(next.value);\n        } else {\n          controller.close();\n        }\n      }\n    }\n\n    this.isWorking = false;\n  }\n\n  /**\n   *\n   * @param {ReadableStreamDefaultController} controller\n   */\n  pull(controller) {\n    if (!this.isWorking) {\n      this.work(controller); // eslint-disable-line @typescript-eslint/no-floating-promises\n    }\n  }\n  cancel() {\n    this.isCancelled = true;\n  }\n}\n"],"file":"blob-stream-controller.js"}

package/dist/es5/node/file/blob-stream.js

@@ -7,32 +7,87 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.BlobStream = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+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 _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
+var _asyncGeneratorDelegate2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncGeneratorDelegate"));
+
 var _readableStream = require("./readable-stream");
 
 var _blobStreamController = require("./blob-stream-controller");
 
-let _Symbol$asyncIterator;
+var _Symbol$asyncIterator;
+
+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; } }
 
 _Symbol$asyncIterator = Symbol.asyncIterator;
 
-class BlobStream extends _readableStream.ReadableStreamPolyfill {
-  constructor(chunks) {
-    super(new _blobStreamController.BlobStreamController(chunks.values()), {
+var BlobStream = function (_ReadableStreamPolyfi) {
+  (0, _inherits2.default)(BlobStream, _ReadableStreamPolyfi);
+
+  var _super = _createSuper(BlobStream);
+
+  function BlobStream(chunks) {
+    var _this2;
+
+    (0, _classCallCheck2.default)(this, BlobStream);
+    _this2 = _super.call(this, new _blobStreamController.BlobStreamController(chunks.values()), {
       type: 'bytes'
     });
-    (0, _defineProperty2.default)(this, "_chunks", void 0);
-    this._chunks = chunks;
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), "_chunks", void 0);
+    _this2._chunks = chunks;
+    return _this2;
   }
 
-  async *[_Symbol$asyncIterator](_options) {
-    const reader = this.getReader();
-    yield* this._chunks;
-    reader.releaseLock();
-  }
+  (0, _createClass2.default)(BlobStream, [{
+    key: _Symbol$asyncIterator,
+    value: function value(_options) {
+      var _this = this;
+
+      return (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee() {
+        var reader;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                reader = _this.getReader();
+                return _context.delegateYield((0, _asyncGeneratorDelegate2.default)((0, _asyncIterator2.default)(_this._chunks), _awaitAsyncGenerator2.default), "t0", 2);
+
+              case 2:
+                reader.releaseLock();
 
-}
+              case 3:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }))();
+    }
+  }]);
+  return BlobStream;
+}(_readableStream.ReadableStreamPolyfill);
 
 exports.BlobStream = BlobStream;
 //# sourceMappingURL=blob-stream.js.map

package/dist/es5/node/file/blob-stream.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/node/file/blob-stream.ts"],"names":["Symbol","asyncIterator","BlobStream","ReadableStreamPolyfill","constructor","chunks","BlobStreamController","values","type","_chunks","_options","reader","getReader","releaseLock"],"mappings":";;;;;;;;;;;AAIA;;AACA;;;;wBAyBUA,MAAM,CAACC,a;;AAhBV,MAAMC,UAAN,SAA4BC,sCAA5B,CAAsD;AAK3DC,EAAAA,WAAW,CAACC,MAAD,EAAS;AAElB,UAAM,IAAIC,0CAAJ,CAAyBD,MAAM,CAACE,MAAP,EAAzB,CAAN,EAAiD;AAACC,MAAAA,IAAI,EAAE;AAAP,KAAjD;AAFkB;AAIlB,SAAKC,OAAL,GAAeJ,MAAf;AACD;;AAMD,iCAA8BK,QAA9B,EAA+F;AAC7F,UAAMC,MAAM,GAAG,KAAKC,SAAL,EAAf;AACA,WAAO,KAAKH,OAAZ;AACAE,IAAAA,MAAM,CAACE,WAAP;AACD;;AApB0D","sourcesContent":["/**\n * Forked from @gozala's web-blob under MIT license\n * @see https://github.com/Gozala/web-blob\n */\nimport {ReadableStreamPolyfill} from './readable-stream';\nimport {BlobStreamController} from './blob-stream-controller';\n\n/**\n * Blob stream is a `ReadableStream` extension optimized to have minimal\n * overhead when consumed as `AsyncIterable<Uint8Array>`.\n * extends {ReadableStream<Uint8Array>}\n * implements {AsyncIterable<Uint8Array>}\n */\n// @ts-ignore\nexport class BlobStream<T> extends ReadableStreamPolyfill<T> {\n  private readonly _chunks: Uint8Array[];\n  /**\n   * @param chunks\n   */\n  constructor(chunks) {\n    // @ts-ignore\n    super(new BlobStreamController(chunks.values()), {type: 'bytes'});\n    /** @private */\n    this._chunks = chunks;\n  }\n\n  /**\n   * @property [_options.preventCancel]\n   */\n  // @ts-ignore\n  async *[Symbol.asyncIterator](_options?: {preventCancel?: boolean}): AsyncIterable<Uint8Array> {\n    const reader = this.getReader();\n    yield* this._chunks;\n    reader.releaseLock();\n  }\n}\n"],"file":"blob-stream.js"}
+{"version":3,"sources":["../../../../src/node/file/blob-stream.ts"],"names":["Symbol","asyncIterator","BlobStream","chunks","BlobStreamController","values","type","_chunks","_options","reader","getReader","releaseLock","ReadableStreamPolyfill"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;AACA;;;;;;;;wBAyBUA,MAAM,CAACC,a;;IAhBJC,U;;;;;AAKX,sBAAYC,MAAZ,EAAoB;AAAA;;AAAA;AAElB,+BAAM,IAAIC,0CAAJ,CAAyBD,MAAM,CAACE,MAAP,EAAzB,CAAN,EAAiD;AAACC,MAAAA,IAAI,EAAE;AAAP,KAAjD;AAFkB;AAIlB,WAAKC,OAAL,GAAeJ,MAAf;AAJkB;AAKnB;;;;WAMD,eAA8BK,QAA9B,EAA+F;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACvFC,gBAAAA,MADuF,GAC9E,KAAI,CAACC,SAAL,EAD8E;AAE7F,iHAAO,KAAI,CAACH,OAAZ;;AAF6F;AAG7FE,gBAAAA,MAAM,CAACE,WAAP;;AAH6F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAI9F;;;EApBgCC,sC","sourcesContent":["/**\n * Forked from @gozala's web-blob under MIT license\n * @see https://github.com/Gozala/web-blob\n */\nimport {ReadableStreamPolyfill} from './readable-stream';\nimport {BlobStreamController} from './blob-stream-controller';\n\n/**\n * Blob stream is a `ReadableStream` extension optimized to have minimal\n * overhead when consumed as `AsyncIterable<Uint8Array>`.\n * extends {ReadableStream<Uint8Array>}\n * implements {AsyncIterable<Uint8Array>}\n */\n// @ts-ignore\nexport class BlobStream<T> extends ReadableStreamPolyfill<T> {\n  private readonly _chunks: Uint8Array[];\n  /**\n   * @param chunks\n   */\n  constructor(chunks) {\n    // @ts-ignore\n    super(new BlobStreamController(chunks.values()), {type: 'bytes'});\n    /** @private */\n    this._chunks = chunks;\n  }\n\n  /**\n   * @property [_options.preventCancel]\n   */\n  // @ts-ignore\n  async *[Symbol.asyncIterator](_options?: {preventCancel?: boolean}): AsyncIterable<Uint8Array> {\n    const reader = this.getReader();\n    yield* this._chunks;\n    reader.releaseLock();\n  }\n}\n"],"file":"blob-stream.js"}

package/dist/es5/node/file/blob.js

@@ -7,144 +7,253 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.BlobPolyfill = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+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 _blobStream = require("./blob-stream");
 
-let _Symbol$toStringTag;
+var _Symbol$toStringTag;
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 _Symbol$toStringTag = Symbol.toStringTag;
 
-class BlobPolyfill {
-  constructor(init = [], options = {}) {
+var BlobPolyfill = function () {
+  function BlobPolyfill() {
+    var init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck2.default)(this, BlobPolyfill);
     (0, _defineProperty2.default)(this, "type", void 0);
     (0, _defineProperty2.default)(this, "size", void 0);
     (0, _defineProperty2.default)(this, "parts", void 0);
     this.parts = [];
     this.size = 0;
 
-    for (const part of init) {
-      if (typeof part === 'string') {
-        const bytes = new TextEncoder().encode(part);
-        this.parts.push(bytes);
-        this.size += bytes.byteLength;
-      } else if (part instanceof BlobPolyfill) {
-        this.size += part.size;
-        this.parts.push(...part.parts);
-      } else if (part instanceof ArrayBuffer) {
-        this.parts.push(new Uint8Array(part));
-        this.size += part.byteLength;
-      } else if (part instanceof Uint8Array) {
-        this.parts.push(part);
-        this.size += part.byteLength;
-      } else if (ArrayBuffer.isView(part)) {
-        const {
-          buffer,
-          byteOffset,
-          byteLength
-        } = part;
-        this.parts.push(new Uint8Array(buffer, byteOffset, byteLength));
-        this.size += byteLength;
-      } else {
-        const bytes = new TextEncoder().encode(String(part));
-        this.parts.push(bytes);
-        this.size += bytes.byteLength;
+    var _iterator = _createForOfIteratorHelper(init),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var part = _step.value;
+
+        if (typeof part === 'string') {
+          var bytes = new TextEncoder().encode(part);
+          this.parts.push(bytes);
+          this.size += bytes.byteLength;
+        } else if (part instanceof BlobPolyfill) {
+          var _this$parts;
+
+          this.size += part.size;
+
+          (_this$parts = this.parts).push.apply(_this$parts, (0, _toConsumableArray2.default)(part.parts));
+        } else if (part instanceof ArrayBuffer) {
+          this.parts.push(new Uint8Array(part));
+          this.size += part.byteLength;
+        } else if (part instanceof Uint8Array) {
+          this.parts.push(part);
+          this.size += part.byteLength;
+        } else if (ArrayBuffer.isView(part)) {
+          var buffer = part.buffer,
+              byteOffset = part.byteOffset,
+              byteLength = part.byteLength;
+          this.parts.push(new Uint8Array(buffer, byteOffset, byteLength));
+          this.size += byteLength;
+        } else {
+          var _bytes = new TextEncoder().encode(String(part));
+
+          this.parts.push(_bytes);
+          this.size += _bytes.byteLength;
+        }
       }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
     }
 
     this.type = readType(options.type);
   }
 
-  slice(start = 0, end = this.size, type = '') {
-    const {
-      size,
-      parts: parts
-    } = this;
-    let offset = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
-    let limit = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
-    const span = Math.max(limit - offset, 0);
-    const blob = new BlobPolyfill([], {
-      type
-    });
-
-    if (span === 0) {
-      return blob;
-    }
+  (0, _createClass2.default)(BlobPolyfill, [{
+    key: "slice",
+    value: function slice() {
+      var start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.size;
+      var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      var size = this.size,
+          parts = this.parts;
+      var offset = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+      var limit = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+      var span = Math.max(limit - offset, 0);
+      var blob = new BlobPolyfill([], {
+        type: type
+      });
 
-    let blobSize = 0;
-    const blobParts = [];
-
-    for (const part of parts) {
-      const {
-        byteLength
-      } = part;
-
-      if (offset > 0 && byteLength <= offset) {
-        offset -= byteLength;
-        limit -= byteLength;
-      } else {
-        const chunk = part.subarray(offset, Math.min(byteLength, limit));
-        blobParts.push(chunk);
-        blobSize += chunk.byteLength;
-        offset = 0;
-
-        if (blobSize >= span) {
-          break;
-        }
+      if (span === 0) {
+        return blob;
       }
-    }
 
-    blob.parts = blobParts;
-    blob.size = blobSize;
-    return blob;
-  }
+      var blobSize = 0;
+      var blobParts = [];
 
-  async arrayBuffer() {
-    return this._toArrayBuffer();
-  }
+      var _iterator2 = _createForOfIteratorHelper(parts),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var part = _step2.value;
+          var byteLength = part.byteLength;
 
-  async text() {
-    const decoder = new TextDecoder();
-    let text = '';
+          if (offset > 0 && byteLength <= offset) {
+            offset -= byteLength;
+            limit -= byteLength;
+          } else {
+            var chunk = part.subarray(offset, Math.min(byteLength, limit));
+            blobParts.push(chunk);
+            blobSize += chunk.byteLength;
+            offset = 0;
 
-    for (const part of this.parts) {
-      text += decoder.decode(part);
+            if (blobSize >= span) {
+              break;
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      blob.parts = blobParts;
+      blob.size = blobSize;
+      return blob;
     }
+  }, {
+    key: "arrayBuffer",
+    value: function () {
+      var _arrayBuffer = (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", this._toArrayBuffer());
 
-    return text;
-  }
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-  stream() {
-    return new _blobStream.BlobStream(this.parts);
-  }
+      function arrayBuffer() {
+        return _arrayBuffer.apply(this, arguments);
+      }
 
-  toString() {
-    return '[object Blob]';
-  }
+      return arrayBuffer;
+    }()
+  }, {
+    key: "text",
+    value: function () {
+      var _text = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2() {
+        var decoder, text, _iterator3, _step3, part;
 
-  get [_Symbol$toStringTag]() {
-    return 'Blob';
-  }
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                decoder = new TextDecoder();
+                text = '';
+                _iterator3 = _createForOfIteratorHelper(this.parts);
+
+                try {
+                  for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                    part = _step3.value;
+                    text += decoder.decode(part);
+                  }
+                } catch (err) {
+                  _iterator3.e(err);
+                } finally {
+                  _iterator3.f();
+                }
+
+                return _context2.abrupt("return", text);
 
-  _toArrayBuffer() {
-    const buffer = new ArrayBuffer(this.size);
-    const bytes = new Uint8Array(buffer);
-    let offset = 0;
+              case 5:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
 
-    for (const part of this.parts) {
-      bytes.set(part, offset);
-      offset += part.byteLength;
+      function text() {
+        return _text.apply(this, arguments);
+      }
+
+      return text;
+    }()
+  }, {
+    key: "stream",
+    value: function stream() {
+      return new _blobStream.BlobStream(this.parts);
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return '[object Blob]';
     }
+  }, {
+    key: _Symbol$toStringTag,
+    get: function get() {
+      return 'Blob';
+    }
+  }, {
+    key: "_toArrayBuffer",
+    value: function _toArrayBuffer() {
+      var buffer = new ArrayBuffer(this.size);
+      var bytes = new Uint8Array(buffer);
+      var offset = 0;
 
-    return buffer;
-  }
+      var _iterator4 = _createForOfIteratorHelper(this.parts),
+          _step4;
 
-}
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var part = _step4.value;
+          bytes.set(part, offset);
+          offset += part.byteLength;
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+
+      return buffer;
+    }
+  }]);
+  return BlobPolyfill;
+}();
 
 exports.BlobPolyfill = BlobPolyfill;
 
-function readType(input = '') {
-  const type = String(input).toLowerCase();
+function readType() {
+  var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var type = String(input).toLowerCase();
   return /[^\u0020-\u007E]/.test(type) ? '' : type;
 }
 //# sourceMappingURL=blob.js.map