@loaders.gl/core 3.4.0-alpha.2 → 3.4.0-alpha.3

package/dist/dist.min.js

@@ -119,8 +119,8 @@
           };
           this.name = jobName;
           this.workerThread = workerThread;
-          this.result = new Promise((resolve, reject) => {
-            this._resolve = resolve;
+          this.result = new Promise((resolve2, reject) => {
+            this._resolve = resolve2;
             this._reject = reject;
           });
         }
@@ -813,8 +813,54 @@
     }
   });
 
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+  var init_typeof = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  var init_toPrimitive = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"() {
+      init_typeof();
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+  var init_toPropertyKey = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"() {
+      init_typeof();
+      init_toPrimitive();
+    }
+  });
+
   // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
   function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
     if (key in obj) {
       Object.defineProperty(obj, key, {
         value,
@@ -829,6 +875,7 @@
   }
   var init_defineProperty = __esm({
     "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
+      init_toPropertyKey();
     }
   });
 
@@ -1089,8 +1136,8 @@
             return this.requestMap.get(handle);
           }
           const request = { handle, priority: 0, getPriority };
-          const promise = new Promise((resolve) => {
-            request.resolve = resolve;
+          const promise = new Promise((resolve2) => {
+            request.resolve = resolve2;
             return request;
           });
           this.requestQueue.push(request);
@@ -1099,7 +1146,7 @@
           return promise;
         }
         _issueRequest(request) {
-          const { handle, resolve } = request;
+          const { handle, resolve: resolve2 } = request;
           let isDone = false;
           const done = () => {
             if (!isDone) {
@@ -1110,7 +1157,7 @@
             }
           };
           this.activeRequestCount++;
-          return resolve ? resolve({ done }) : Promise.resolve({ done });
+          return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
         }
         _issueNewRequests() {
           if (!this.deferredUpdate) {
@@ -1256,29 +1303,43 @@
 
   // ../loader-utils/src/lib/node/promisify.ts
   function promisify2(fn) {
-    return (arg1, arg2) => new Promise((resolve, reject) => fn(arg1, arg2, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
+    return (arg1, arg2) => new Promise((resolve2, reject) => fn(arg1, arg2, (error, callbackArgs) => error ? reject(error) : resolve2(callbackArgs)));
   }
   function promisify3(fn) {
-    return (arg1, arg2, arg3) => new Promise((resolve, reject) => fn(arg1, arg2, arg3, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
+    return (arg1, arg2, arg3) => new Promise((resolve2, reject) => fn(arg1, arg2, arg3, (error, callbackArgs) => error ? reject(error) : resolve2(callbackArgs)));
   }
   var init_promisify = __esm({
     "../loader-utils/src/lib/node/promisify.ts"() {
     }
   });
 
+  // ../loader-utils/src/lib/path-utils/get-cwd.ts
+  function getCWD() {
+    if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
+      return process.cwd();
+    }
+    const pathname = window.location?.pathname;
+    return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || "";
+  }
+  var init_get_cwd = __esm({
+    "../loader-utils/src/lib/path-utils/get-cwd.ts"() {
+    }
+  });
+
   // ../loader-utils/src/lib/path-utils/path.ts
   var path_exports = {};
   __export(path_exports, {
     dirname: () => dirname,
     filename: () => filename,
-    join: () => join
+    join: () => join,
+    resolve: () => resolve
   });
   function filename(url) {
-    const slashIndex = url && url.lastIndexOf("/");
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
     return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
   }
   function dirname(url) {
-    const slashIndex = url && url.lastIndexOf("/");
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
     return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
   }
   function join(...parts) {
@@ -1294,8 +1355,112 @@
     });
     return parts.join(separator);
   }
+  function resolve(...components) {
+    const paths = [];
+    for (let _i = 0; _i < components.length; _i++) {
+      paths[_i] = components[_i];
+    }
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    let cwd;
+    for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      let path;
+      if (i >= 0) {
+        path = paths[i];
+      } else {
+        if (cwd === void 0) {
+          cwd = getCWD();
+        }
+        path = cwd;
+      }
+      if (path.length === 0) {
+        continue;
+      }
+      resolvedPath = `${path}/${resolvedPath}`;
+      resolvedAbsolute = path.charCodeAt(0) === SLASH;
+    }
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+      return `/${resolvedPath}`;
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    }
+    return ".";
+  }
+  function normalizeStringPosix(path, allowAboveRoot) {
+    let res = "";
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    let isAboveRoot = false;
+    for (let i = 0; i <= path.length; ++i) {
+      if (i < path.length) {
+        code = path.charCodeAt(i);
+      } else if (code === SLASH) {
+        break;
+      } else {
+        code = SLASH;
+      }
+      if (code === SLASH) {
+        if (lastSlash === i - 1 || dots === 1) {
+        } else if (lastSlash !== i - 1 && dots === 2) {
+          if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+            if (res.length > 2) {
+              const start = res.length - 1;
+              let j = start;
+              for (; j >= 0; --j) {
+                if (res.charCodeAt(j) === SLASH) {
+                  break;
+                }
+              }
+              if (j !== start) {
+                res = j === -1 ? "" : res.slice(0, j);
+                lastSlash = i;
+                dots = 0;
+                isAboveRoot = false;
+                continue;
+              }
+            } else if (res.length === 2 || res.length === 1) {
+              res = "";
+              lastSlash = i;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          }
+          if (allowAboveRoot) {
+            if (res.length > 0) {
+              res += "/..";
+            } else {
+              res = "..";
+            }
+            isAboveRoot = true;
+          }
+        } else {
+          const slice = path.slice(lastSlash + 1, i);
+          if (res.length > 0) {
+            res += `/${slice}`;
+          } else {
+            res = slice;
+          }
+          isAboveRoot = false;
+        }
+        lastSlash = i;
+        dots = 0;
+      } else if (code === DOT && dots !== -1) {
+        ++dots;
+      } else {
+        dots = -1;
+      }
+    }
+    return res;
+  }
+  var SLASH, DOT;
   var init_path = __esm({
     "../loader-utils/src/lib/path-utils/path.ts"() {
+      init_get_cwd();
+      SLASH = 47;
+      DOT = 46;
     }
   });
 
@@ -1345,7 +1510,7 @@
         writeFile = promisify3(import_fs.default.writeFile);
         writeFileSync = import_fs.default.writeFileSync;
         open = import_fs.default.open;
-        close = (fd) => new Promise((resolve, reject) => import_fs.default.close(fd, (err) => err ? reject(err) : resolve()));
+        close = (fd) => new Promise((resolve2, reject) => import_fs.default.close(fd, (err) => err ? reject(err) : resolve2()));
         read = import_fs.default.read;
         fstat = import_fs.default.fstat;
         createWriteStream = import_fs.default.createWriteStream;
@@ -1530,9 +1695,9 @@
     }
     if (resource instanceof Blob) {
       const blobSlice = resource.slice(0, 5);
-      return await new Promise((resolve) => {
+      return await new Promise((resolve2) => {
         const reader = new FileReader();
-        reader.onload = (event) => resolve(event?.target?.result);
+        reader.onload = (event) => resolve2(event?.target?.result);
         reader.readAsDataURL(blobSlice);
       });
     }
@@ -1589,9 +1754,9 @@
     return await readBlob(slice);
   }
   async function readBlob(blob) {
-    return await new Promise((resolve, reject) => {
+    return await new Promise((resolve2, reject) => {
       const fileReader = new FileReader();
-      fileReader.onload = (event) => resolve(event?.target?.result);
+      fileReader.onload = (event) => resolve2(event?.target?.result);
       fileReader.onerror = (error) => reject(error);
       fileReader.readAsArrayBuffer(blob);
     });
@@ -3431,8 +3596,8 @@
       return response;
     }
     const contentLength = response.headers.get("content-length") || 0;
-    const totalBytes = contentLength && parseInt(contentLength);
-    if (!(contentLength > 0)) {
+    const totalBytes = contentLength ? parseInt(contentLength) : 0;
+    if (!(totalBytes > 0)) {
       return response;
     }
     if (typeof ReadableStream === "undefined" || !body.getReader) {

package/dist/es5/core-addons/write-file-browser.js

@@ -1,4 +1,2 @@
-
-
 "use strict";
 //# sourceMappingURL=write-file-browser.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n// TYPES\nexport type {\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions,\n  Writer,\n  WriterOptions,\n  DataType,\n  SyncDataType,\n  BatchableDataType,\n  IFileSystem,\n  IRandomAccessReadFileSystem\n} from '@loaders.gl/loader-utils';\n\n// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions, getLoaderOptions} from './lib/api/loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {default as _fetchProgress} from './lib/progress/fetch-progress';\nexport {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA;AAEA;AACA;AACA;AAGA;AACA;AACA;AAGA;AACA;AACA;AAEA;AACA;AAGA;AACA;AAGA;AAIA;AACA;AAGA;AAIA;AACA;AAqBA"}
+{"version":3,"file":"index.js","names":["_fetchFile","require","_readArrayBuffer","_readFile","_writeFile","_loaderOptions","_registerLoaders","_selectLoader","_parse","_parseSync","_parseInBatches","_load","_loadInBatches","_encode","_save","_loaderUtils","_makeIterator","_makeNodeStream","_nullLoader","_fetchProgress","_interopRequireDefault","_browserFilesystem","_isType"],"sources":["../../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n// TYPES\nexport type {\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions,\n  Writer,\n  WriterOptions,\n  DataType,\n  SyncDataType,\n  BatchableDataType,\n  IFileSystem,\n  IRandomAccessReadFileSystem\n} from '@loaders.gl/loader-utils';\n\n// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions, getLoaderOptions} from './lib/api/loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {default as _fetchProgress} from './lib/progress/fetch-progress';\nexport {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,IAAAA,UAAA,GAAAC,OAAA;AAEA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AACA,IAAAG,UAAA,GAAAH,OAAA;AAGA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,gBAAA,GAAAL,OAAA;AACA,IAAAM,aAAA,GAAAN,OAAA;AAGA,IAAAO,MAAA,GAAAP,OAAA;AACA,IAAAQ,UAAA,GAAAR,OAAA;AACA,IAAAS,eAAA,GAAAT,OAAA;AAEA,IAAAU,KAAA,GAAAV,OAAA;AACA,IAAAW,cAAA,GAAAX,OAAA;AAGA,IAAAY,OAAA,GAAAZ,OAAA;AACA,IAAAa,KAAA,GAAAb,OAAA;AAGA,IAAAc,YAAA,GAAAd,OAAA;AAIA,IAAAe,aAAA,GAAAf,OAAA;AACA,IAAAgB,eAAA,GAAAhB,OAAA;AAGA,IAAAiB,WAAA,GAAAjB,OAAA;AAIA,IAAAkB,cAAA,GAAAC,sBAAA,CAAAnB,OAAA;AACA,IAAAoB,kBAAA,GAAAD,sBAAA,CAAAnB,OAAA;AAqBA,IAAAqB,OAAA,GAAArB,OAAA"}

package/dist/es5/iterators/batch-iterators/timed-batch-iterator.js

@@ -17,77 +17,75 @@ function _timedBatchIterator() {
   _timedBatchIterator = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(batchIterator, timeout) {
     var start, batches, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, batch;
     return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            start = Date.now();
-            batches = [];
-            _iteratorAbruptCompletion = false;
-            _didIteratorError = false;
-            _context.prev = 4;
-            _iterator = _asyncIterator(batchIterator);
-          case 6:
-            _context.next = 8;
-            return (0, _awaitAsyncGenerator2.default)(_iterator.next());
-          case 8:
-            if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
-              _context.next = 19;
-              break;
-            }
-            batch = _step.value;
-            batches.push(batch);
-            if (!(Date.now() - start > timeout)) {
-              _context.next = 16;
-              break;
-            }
-            _context.next = 14;
-            return batches;
-          case 14:
-            start = Date.now();
-            batches = [];
-          case 16:
-            _iteratorAbruptCompletion = false;
-            _context.next = 6;
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          start = Date.now();
+          batches = [];
+          _iteratorAbruptCompletion = false;
+          _didIteratorError = false;
+          _context.prev = 4;
+          _iterator = _asyncIterator(batchIterator);
+        case 6:
+          _context.next = 8;
+          return (0, _awaitAsyncGenerator2.default)(_iterator.next());
+        case 8:
+          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
+            _context.next = 19;
             break;
-          case 19:
-            _context.next = 25;
+          }
+          batch = _step.value;
+          batches.push(batch);
+          if (!(Date.now() - start > timeout)) {
+            _context.next = 16;
             break;
-          case 21:
-            _context.prev = 21;
-            _context.t0 = _context["catch"](4);
-            _didIteratorError = true;
-            _iteratorError = _context.t0;
-          case 25:
-            _context.prev = 25;
-            _context.prev = 26;
-            if (!(_iteratorAbruptCompletion && _iterator.return != null)) {
-              _context.next = 30;
-              break;
-            }
+          }
+          _context.next = 14;
+          return batches;
+        case 14:
+          start = Date.now();
+          batches = [];
+        case 16:
+          _iteratorAbruptCompletion = false;
+          _context.next = 6;
+          break;
+        case 19:
+          _context.next = 25;
+          break;
+        case 21:
+          _context.prev = 21;
+          _context.t0 = _context["catch"](4);
+          _didIteratorError = true;
+          _iteratorError = _context.t0;
+        case 25:
+          _context.prev = 25;
+          _context.prev = 26;
+          if (!(_iteratorAbruptCompletion && _iterator.return != null)) {
             _context.next = 30;
-            return (0, _awaitAsyncGenerator2.default)(_iterator.return());
-          case 30:
-            _context.prev = 30;
-            if (!_didIteratorError) {
-              _context.next = 33;
-              break;
-            }
-            throw _iteratorError;
-          case 33:
-            return _context.finish(30);
-          case 34:
-            return _context.finish(25);
-          case 35:
-            if (!batches) {
-              _context.next = 38;
-              break;
-            }
+            break;
+          }
+          _context.next = 30;
+          return (0, _awaitAsyncGenerator2.default)(_iterator.return());
+        case 30:
+          _context.prev = 30;
+          if (!_didIteratorError) {
+            _context.next = 33;
+            break;
+          }
+          throw _iteratorError;
+        case 33:
+          return _context.finish(30);
+        case 34:
+          return _context.finish(25);
+        case 35:
+          if (!batches) {
             _context.next = 38;
-            return batches;
-          case 38:
-          case "end":
-            return _context.stop();
-        }
+            break;
+          }
+          _context.next = 38;
+          return batches;
+        case 38:
+        case "end":
+          return _context.stop();
       }
     }, _callee, null, [[4, 21, 25, 35], [26,, 30, 34]]);
   }));

package/dist/es5/iterators/batch-iterators/timed-batch-iterator.js.map

@@ -1 +1 @@
-{"version":3,"file":"timed-batch-iterator.js","names":["timedBatchIterator","batchIterator","timeout","start","Date","now","batches","batch","push"],"sources":["../../../../src/iterators/batch-iterators/timed-batch-iterator.ts"],"sourcesContent":["/**\n * \"Debounces\" batches and returns them in groups\n */\nexport async function* timedBatchIterator<Batch>(batchIterator: AsyncIterable<Batch>, timeout) {\n  let start = Date.now();\n  let batches: Batch[] = [];\n  for await (const batch of batchIterator) {\n    batches.push(batch);\n    if (Date.now() - start > timeout) {\n      yield batches;\n      start = Date.now();\n      batches = [];\n    }\n  }\n\n  if (batches) {\n    yield batches;\n  }\n}\n"],"mappings":";;;;;;;;;;;;SAGuBA,kBAAkB;EAAA;AAAA;AAAA;EAAA,kFAAlC,iBAA0CC,aAAmC,EAAEC,OAAO;IAAA;IAAA;MAAA;QAAA;UAAA;YACvFC,KAAK,GAAGC,IAAI,CAACC,GAAG,EAAE;YAClBC,OAAgB,GAAG,EAAE;YAAA;YAAA;YAAA;YAAA,2BACCL,aAAa;UAAA;YAAA;YAAA;UAAA;YAAA;cAAA;cAAA;YAAA;YAAtBM,KAAK;YACpBD,OAAO,CAACE,IAAI,CAACD,KAAK,CAAC;YAAC,MAChBH,IAAI,CAACC,GAAG,EAAE,GAAGF,KAAK,GAAGD,OAAO;cAAA;cAAA;YAAA;YAAA;YAC9B,OAAMI,OAAO;UAAA;YACbH,KAAK,GAAGC,IAAI,CAACC,GAAG,EAAE;YAClBC,OAAO,GAAG,EAAE;UAAC;YAAA;YAAA;YAAA;UAAA;YAAA;YAAA;UAAA;YAAA;YAAA;YAAA;YAAA;UAAA;YAAA;YAAA;YAAA;cAAA;cAAA;YAAA;YAAA;YAAA;UAAA;YAAA;YAAA;cAAA;cAAA;YAAA;YAAA;UAAA;YAAA;UAAA;YAAA;UAAA;YAAA,KAIbA,OAAO;cAAA;cAAA;YAAA;YAAA;YACT,OAAMA,OAAO;UAAA;UAAA;YAAA;QAAA;MAAA;IAAA;EAAA,CAEhB;EAAA;AAAA"}
+{"version":3,"file":"timed-batch-iterator.js","names":["timedBatchIterator","_x","_x2","_timedBatchIterator","apply","arguments","_wrapAsyncGenerator2","default","_regenerator","mark","_callee","batchIterator","timeout","start","batches","_iteratorAbruptCompletion","_didIteratorError","_iteratorError","_iterator","_step","batch","wrap","_callee$","_context","prev","next","Date","now","_asyncIterator","_awaitAsyncGenerator2","sent","done","value","push","t0","return","finish","stop"],"sources":["../../../../src/iterators/batch-iterators/timed-batch-iterator.ts"],"sourcesContent":["/**\n * \"Debounces\" batches and returns them in groups\n */\nexport async function* timedBatchIterator<Batch>(batchIterator: AsyncIterable<Batch>, timeout) {\n  let start = Date.now();\n  let batches: Batch[] = [];\n  for await (const batch of batchIterator) {\n    batches.push(batch);\n    if (Date.now() - start > timeout) {\n      yield batches;\n      start = Date.now();\n      batches = [];\n    }\n  }\n\n  if (batches) {\n    yield batches;\n  }\n}\n"],"mappings":";;;;;;;;;;;;SAGuBA,kBAAkBA,CAAAC,EAAA,EAAAC,GAAA;EAAA,OAAAC,mBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAAA,SAAAF,oBAAA;EAAAA,mBAAA,OAAAG,oBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAlC,SAAAC,QAA0CC,aAAmC,EAAEC,OAAO;IAAA,IAAAC,KAAA,EAAAC,OAAA,EAAAC,yBAAA,EAAAC,iBAAA,EAAAC,cAAA,EAAAC,SAAA,EAAAC,KAAA,EAAAC,KAAA;IAAA,OAAAZ,YAAA,CAAAD,OAAA,CAAAc,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UACvFZ,KAAK,GAAGa,IAAI,CAACC,GAAG,EAAE;UAClBb,OAAgB,GAAG,EAAE;UAAAC,yBAAA;UAAAC,iBAAA;UAAAO,QAAA,CAAAC,IAAA;UAAAN,SAAA,GAAAU,cAAA,CACCjB,aAAa;QAAA;UAAAY,QAAA,CAAAE,IAAA;UAAA,WAAAI,qBAAA,CAAAtB,OAAA,EAAAW,SAAA,CAAAO,IAAA;QAAA;UAAA,MAAAV,yBAAA,KAAAI,KAAA,GAAAI,QAAA,CAAAO,IAAA,EAAAC,IAAA;YAAAR,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAtBL,KAAK,GAAAD,KAAA,CAAAa,KAAA;UACpBlB,OAAO,CAACmB,IAAI,CAACb,KAAK,CAAC;UAAC,MAChBM,IAAI,CAACC,GAAG,EAAE,GAAGd,KAAK,GAAGD,OAAO;YAAAW,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAC9B,OAAMX,OAAO;QAAA;UACbD,KAAK,GAAGa,IAAI,CAACC,GAAG,EAAE;UAClBb,OAAO,GAAG,EAAE;QAAC;UAAAC,yBAAA;UAAAQ,QAAA,CAAAE,IAAA;UAAA;QAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA;QAAA;UAAAF,QAAA,CAAAC,IAAA;UAAAD,QAAA,CAAAW,EAAA,GAAAX,QAAA;UAAAP,iBAAA;UAAAC,cAAA,GAAAM,QAAA,CAAAW,EAAA;QAAA;UAAAX,QAAA,CAAAC,IAAA;UAAAD,QAAA,CAAAC,IAAA;UAAA,MAAAT,yBAAA,IAAAG,SAAA,CAAAiB,MAAA;YAAAZ,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,WAAAI,qBAAA,CAAAtB,OAAA,EAAAW,SAAA,CAAAiB,MAAA;QAAA;UAAAZ,QAAA,CAAAC,IAAA;UAAA,KAAAR,iBAAA;YAAAO,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAA,MAAAR,cAAA;QAAA;UAAA,OAAAM,QAAA,CAAAa,MAAA;QAAA;UAAA,OAAAb,QAAA,CAAAa,MAAA;QAAA;UAAA,KAIbtB,OAAO;YAAAS,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UACT,OAAMX,OAAO;QAAA;QAAA;UAAA,OAAAS,QAAA,CAAAc,IAAA;MAAA;IAAA,GAAA3B,OAAA;EAAA,CAEhB;EAAA,OAAAP,mBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA"}

package/dist/es5/iterators/make-iterator/make-array-buffer-iterator.js

@@ -6,29 +6,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.makeArrayBufferIterator = makeArrayBufferIterator;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _marked = _regenerator.default.mark(makeArrayBufferIterator);
 var DEFAULT_CHUNK_SIZE = 256 * 1024;
-
 function makeArrayBufferIterator(arrayBuffer) {
-  var options,
-    _options$chunkSize,
-    chunkSize,
-    byteOffset,
-    chunkByteLength,
-    chunk,
-    sourceArray,
-    chunkArray,
-    _args = arguments;
-  return _regenerator.default.wrap(function makeArrayBufferIterator$(_context) {
-    while (1) {
-      switch (_context.prev = _context.next) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return _regenerator.default.mark(function _callee() {
+    var _options$chunkSize, chunkSize, byteOffset, chunkByteLength, chunk, sourceArray, chunkArray;
+    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] : {};
           _options$chunkSize = options.chunkSize, chunkSize = _options$chunkSize === void 0 ? DEFAULT_CHUNK_SIZE : _options$chunkSize;
           byteOffset = 0;
-        case 3:
+        case 2:
           if (!(byteOffset < arrayBuffer.byteLength)) {
-            _context.next = 14;
+            _context.next = 13;
             break;
           }
           chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);
@@ -36,18 +26,17 @@ function makeArrayBufferIterator(arrayBuffer) {
           sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);
           chunkArray = new Uint8Array(chunk);
           chunkArray.set(sourceArray);
-
           byteOffset += chunkByteLength;
-          _context.next = 12;
+          _context.next = 11;
           return chunk;
-        case 12:
-          _context.next = 3;
+        case 11:
+          _context.next = 2;
           break;
-        case 14:
+        case 13:
         case "end":
           return _context.stop();
       }
-    }
-  }, _marked);
+    }, _callee);
+  })();
 }
 //# sourceMappingURL=make-array-buffer-iterator.js.map

package/dist/es5/iterators/make-iterator/make-array-buffer-iterator.js.map

@@ -1 +1 @@
-{"version":3,"file":"make-array-buffer-iterator.js","names":["makeArrayBufferIterator","DEFAULT_CHUNK_SIZE","arrayBuffer","options","chunkSize","byteOffset","byteLength","chunkByteLength","Math","min","chunk","ArrayBuffer","sourceArray","Uint8Array","chunkArray","set"],"sources":["../../../../src/iterators/make-iterator/make-array-buffer-iterator.ts"],"sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 256 * 1024;\n\n/**\n * Returns an iterator that breaks a big ArrayBuffer into chunks and yields them one-by-one\n * @param blob ArrayBuffer to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeArrayBufferIterator(\n  arrayBuffer: ArrayBuffer,\n  options: IteratorOptions = {}\n): Iterable<ArrayBuffer> {\n  const {chunkSize = DEFAULT_CHUNK_SIZE} = options;\n\n  let byteOffset = 0;\n\n  while (byteOffset < arrayBuffer.byteLength) {\n    // Create a chunk of the right size\n    const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);\n    const chunk = new ArrayBuffer(chunkByteLength);\n\n    // Copy data from the big chunk\n    const sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);\n    const chunkArray = new Uint8Array(chunk);\n    chunkArray.set(sourceArray);\n\n    // yield the chunk\n    byteOffset += chunkByteLength;\n    yield chunk;\n  }\n}\n"],"mappings":";;;;;;;;wCAUiBA,uBAAuB;AARxC,IAAMC,kBAAkB,GAAG,GAAG,GAAG,IAAI;;AAQ9B,SAAUD,uBAAuB,CACtCE,WAAwB;EAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;EAAA;IAAA;MAAA;QAAA;UACxBC,OAAwB,2DAAG,CAAC,CAAC;UAAA,qBAEYA,OAAO,CAAzCC,SAAS,EAATA,SAAS,mCAAGH,kBAAkB;UAEjCI,UAAU,GAAG,CAAC;QAAA;UAAA,MAEXA,UAAU,GAAGH,WAAW,CAACI,UAAU;YAAA;YAAA;UAAA;UAElCC,eAAe,GAAGC,IAAI,CAACC,GAAG,CAACP,WAAW,CAACI,UAAU,GAAGD,UAAU,EAAED,SAAS,CAAC;UAC1EM,KAAK,GAAG,IAAIC,WAAW,CAACJ,eAAe,CAAC;UAGxCK,WAAW,GAAG,IAAIC,UAAU,CAACX,WAAW,EAAEG,UAAU,EAAEE,eAAe,CAAC;UACtEO,UAAU,GAAG,IAAID,UAAU,CAACH,KAAK,CAAC;UACxCI,UAAU,CAACC,GAAG,CAACH,WAAW,CAAC;;UAG3BP,UAAU,IAAIE,eAAe;UAAC;UAC9B,OAAMG,KAAK;QAAA;UAAA;UAAA;QAAA;QAAA;UAAA;MAAA;IAAA;EAAA;AAAA"}
+{"version":3,"file":"make-array-buffer-iterator.js","names":["DEFAULT_CHUNK_SIZE","makeArrayBufferIterator","arrayBuffer","options","arguments","length","undefined","_regenerator","default","mark","_callee","_options$chunkSize","chunkSize","byteOffset","chunkByteLength","chunk","sourceArray","chunkArray","wrap","_callee$","_context","prev","next","byteLength","Math","min","ArrayBuffer","Uint8Array","set","stop"],"sources":["../../../../src/iterators/make-iterator/make-array-buffer-iterator.ts"],"sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 256 * 1024;\n\n/**\n * Returns an iterator that breaks a big ArrayBuffer into chunks and yields them one-by-one\n * @param blob ArrayBuffer to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeArrayBufferIterator(\n  arrayBuffer: ArrayBuffer,\n  options: IteratorOptions = {}\n): Iterable<ArrayBuffer> {\n  const {chunkSize = DEFAULT_CHUNK_SIZE} = options;\n\n  let byteOffset = 0;\n\n  while (byteOffset < arrayBuffer.byteLength) {\n    // Create a chunk of the right size\n    const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);\n    const chunk = new ArrayBuffer(chunkByteLength);\n\n    // Copy data from the big chunk\n    const sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);\n    const chunkArray = new Uint8Array(chunk);\n    chunkArray.set(sourceArray);\n\n    // yield the chunk\n    byteOffset += chunkByteLength;\n    yield chunk;\n  }\n}\n"],"mappings":";;;;;;;;AAEA,IAAMA,kBAAkB,GAAG,GAAG,GAAG,IAAI;AAQ9B,SAAUC,uBAAuBA,CACtCC,WAAwB;EAAA,IACxBC,OAAwB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAAA,OAAAG,YAAA,CAAAC,OAAA,CAAAC,IAAA,UAAAC,QAAA;IAAA,IAAAC,kBAAA,EAAAC,SAAA,EAAAC,UAAA,EAAAC,eAAA,EAAAC,KAAA,EAAAC,WAAA,EAAAC,UAAA;IAAA,OAAAV,YAAA,CAAAC,OAAA,CAAAU,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAAAX,kBAAA,GAEYR,OAAO,CAAzCS,SAAS,EAATA,SAAS,GAAAD,kBAAA,cAAGX,kBAAkB,GAAAW,kBAAA;UAEjCE,UAAU,GAAG,CAAC;QAAA;UAAA,MAEXA,UAAU,GAAGX,WAAW,CAACqB,UAAU;YAAAH,QAAA,CAAAE,IAAA;YAAA;UAAA;UAElCR,eAAe,GAAGU,IAAI,CAACC,GAAG,CAACvB,WAAW,CAACqB,UAAU,GAAGV,UAAU,EAAED,SAAS,CAAC;UAC1EG,KAAK,GAAG,IAAIW,WAAW,CAACZ,eAAe,CAAC;UAGxCE,WAAW,GAAG,IAAIW,UAAU,CAACzB,WAAW,EAAEW,UAAU,EAAEC,eAAe,CAAC;UACtEG,UAAU,GAAG,IAAIU,UAAU,CAACZ,KAAK,CAAC;UACxCE,UAAU,CAACW,GAAG,CAACZ,WAAW,CAAC;UAG3BH,UAAU,IAAIC,eAAe;UAACM,QAAA,CAAAE,IAAA;UAC9B,OAAMP,KAAK;QAAA;UAAAK,QAAA,CAAAE,IAAA;UAAA;QAAA;QAAA;UAAA,OAAAF,QAAA,CAAAS,IAAA;MAAA;IAAA,GAAAnB,OAAA;EAAA;AAAA"}

package/dist/es5/iterators/make-iterator/make-blob-iterator.js

@@ -9,7 +9,6 @@ var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"))
 var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
 var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
 var DEFAULT_CHUNK_SIZE = 1024 * 1024;
-
 function makeBlobIterator(_x, _x2) {
   return _makeBlobIterator.apply(this, arguments);
 }
@@ -17,31 +16,29 @@ function _makeBlobIterator() {
   _makeBlobIterator = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(blob, options) {
     var chunkSize, offset, end, chunk;
     return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
-            offset = 0;
-          case 2:
-            if (!(offset < blob.size)) {
-              _context.next = 12;
-              break;
-            }
-            end = offset + chunkSize;
-            _context.next = 6;
-            return (0, _awaitAsyncGenerator2.default)(blob.slice(offset, end).arrayBuffer());
-          case 6:
-            chunk = _context.sent;
-            offset = end;
-            _context.next = 10;
-            return chunk;
-          case 10:
-            _context.next = 2;
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
+          offset = 0;
+        case 2:
+          if (!(offset < blob.size)) {
+            _context.next = 12;
             break;
-          case 12:
-          case "end":
-            return _context.stop();
-        }
+          }
+          end = offset + chunkSize;
+          _context.next = 6;
+          return (0, _awaitAsyncGenerator2.default)(blob.slice(offset, end).arrayBuffer());
+        case 6:
+          chunk = _context.sent;
+          offset = end;
+          _context.next = 10;
+          return chunk;
+        case 10:
+          _context.next = 2;
+          break;
+        case 12:
+        case "end":
+          return _context.stop();
       }
     }, _callee);
   }));

package/dist/es5/iterators/make-iterator/make-blob-iterator.js.map

@@ -1 +1 @@
-{"version":3,"file":"make-blob-iterator.js","names":["DEFAULT_CHUNK_SIZE","makeBlobIterator","blob","options","chunkSize","offset","size","end","slice","arrayBuffer","chunk"],"sources":["../../../../src/iterators/make-iterator/make-blob-iterator.ts"],"sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 1024 * 1024; // 1MB — biggest value that keeps UI responsive\n\n/**\n * Returns an iterator that breaks a big Blob into chunks and yields them one-by-one\n * @param blob Blob or File object\n * @param options\n * @param options.chunkSize\n */\nexport async function* makeBlobIterator(\n  blob: Blob,\n  options?: IteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n  let offset = 0;\n  while (offset < blob.size) {\n    const end = offset + chunkSize;\n\n    const chunk = await blob.slice(offset, end).arrayBuffer();\n\n    offset = end;\n    yield chunk;\n  }\n}\n"],"mappings":";;;;;;;;;;AAEA,IAAMA,kBAAkB,GAAG,IAAI,GAAG,IAAI;;AAAC,SAQhBC,gBAAgB;EAAA;AAAA;AAAA;EAAA,gFAAhC,iBACLC,IAAU,EACVC,OAAyB;IAAA;IAAA;MAAA;QAAA;UAAA;YAEnBC,SAAS,GAAG,CAAAD,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEC,SAAS,KAAIJ,kBAAkB;YAEtDK,MAAM,GAAG,CAAC;UAAA;YAAA,MACPA,MAAM,GAAGH,IAAI,CAACI,IAAI;cAAA;cAAA;YAAA;YACjBC,GAAG,GAAGF,MAAM,GAAGD,SAAS;YAAA;YAAA,0CAEVF,IAAI,CAACM,KAAK,CAACH,MAAM,EAAEE,GAAG,CAAC,CAACE,WAAW,EAAE;UAAA;YAAnDC,KAAK;YAEXL,MAAM,GAAGE,GAAG;YAAC;YACb,OAAMG,KAAK;UAAA;YAAA;YAAA;UAAA;UAAA;YAAA;QAAA;MAAA;IAAA;EAAA,CAEd;EAAA;AAAA"}
+{"version":3,"file":"make-blob-iterator.js","names":["DEFAULT_CHUNK_SIZE","makeBlobIterator","_x","_x2","_makeBlobIterator","apply","arguments","_wrapAsyncGenerator2","default","_regenerator","mark","_callee","blob","options","chunkSize","offset","end","chunk","wrap","_callee$","_context","prev","next","size","_awaitAsyncGenerator2","slice","arrayBuffer","sent","stop"],"sources":["../../../../src/iterators/make-iterator/make-blob-iterator.ts"],"sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 1024 * 1024; // 1MB — biggest value that keeps UI responsive\n\n/**\n * Returns an iterator that breaks a big Blob into chunks and yields them one-by-one\n * @param blob Blob or File object\n * @param options\n * @param options.chunkSize\n */\nexport async function* makeBlobIterator(\n  blob: Blob,\n  options?: IteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n  let offset = 0;\n  while (offset < blob.size) {\n    const end = offset + chunkSize;\n\n    const chunk = await blob.slice(offset, end).arrayBuffer();\n\n    offset = end;\n    yield chunk;\n  }\n}\n"],"mappings":";;;;;;;;;;AAEA,IAAMA,kBAAkB,GAAG,IAAI,GAAG,IAAI;AAAC,SAQhBC,gBAAgBA,CAAAC,EAAA,EAAAC,GAAA;EAAA,OAAAC,iBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAAA,SAAAF,kBAAA;EAAAA,iBAAA,OAAAG,oBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAhC,SAAAC,QACLC,IAAU,EACVC,OAAyB;IAAA,IAAAC,SAAA,EAAAC,MAAA,EAAAC,GAAA,EAAAC,KAAA;IAAA,OAAAR,YAAA,CAAAD,OAAA,CAAAU,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAEnBR,SAAS,GAAG,CAAAD,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEC,SAAS,KAAId,kBAAkB;UAEtDe,MAAM,GAAG,CAAC;QAAA;UAAA,MACPA,MAAM,GAAGH,IAAI,CAACW,IAAI;YAAAH,QAAA,CAAAE,IAAA;YAAA;UAAA;UACjBN,GAAG,GAAGD,MAAM,GAAGD,SAAS;UAAAM,QAAA,CAAAE,IAAA;UAAA,WAAAE,qBAAA,CAAAhB,OAAA,EAEVI,IAAI,CAACa,KAAK,CAACV,MAAM,EAAEC,GAAG,CAAC,CAACU,WAAW,EAAE;QAAA;UAAnDT,KAAK,GAAAG,QAAA,CAAAO,IAAA;UAEXZ,MAAM,GAAGC,GAAG;UAACI,QAAA,CAAAE,IAAA;UACb,OAAML,KAAK;QAAA;UAAAG,QAAA,CAAAE,IAAA;UAAA;QAAA;QAAA;UAAA,OAAAF,QAAA,CAAAQ,IAAA;MAAA;IAAA,GAAAjB,OAAA;EAAA,CAEd;EAAA,OAAAP,iBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA"}