@loaders.gl/core 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/es5/bundle.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var moduleExports = require('./index');
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/es5/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"write-file-browser.js","names":[],"sources":["../../../src/core-addons/write-file-browser.ts"],"sourcesContent":["// A browser implementation of the Node.js `fs` module's `fs.writeFile` method.\n// NOTE: WAS COMMENTED OUT TO GET NODE 8 TESTS RUNNING\n\n/*\n/* global global *\n/* global Blob *\nimport {isBrowser} from '@loaders.gl/core';\n\n// TODO hack - trick filesaver.js to skip loading under node\nconst savedNavigatorExists = 'navigator' in global;\nconst savedNavigator = global.navigator;\nif (!isBrowser) {\n  global.navigator = {userAgent: 'MSIE 9.'};\n}\n\n// Need to use `require` to ensure our modification of global code above happens first\nconst saveAs = require('filesaver.js');\n\nif (!isBrowser) {\n  if (savedNavigatorExists) {\n    global.navigator = savedNavigator;\n  } else {\n    delete global.navigator;\n  }\n}\n// END hack\n\n/**\n * File system write function for the browser, similar to Node's fs.writeFile\n *\n * Saves a file by downloading it with the given file name.\n *\n * @param {String} file - file name\n * @param {String|Blob} data - data to be written to file\n * @param {String|Object} options -\n * @param {Function} callback - Standard node (err, data) callback\n * @return {Promise} - promise, can be used instead of callback\n *\nasync export function writeFile(file, data, options, callback = () => {}) {\n  // options is optional\n  if (callback === undefined && typeof options === 'function') {\n    options = undefined;\n    callback = options;\n  }\n  if (typeof data === 'string') {\n    data = new Blob(data);\n  }\n  return new Promise((resolve, reject) => {\n    let result;\n    try {\n      result = saveAs(data, file, options);\n    } catch (error) {\n      reject(error);\n      return callback(error, null);\n    }\n    resolve();\n    return callback(null, result);\n  });\n}\n*/\n"],"mappings":""}

package/dist/es5/index.js

@@ -0,0 +1,377 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "JSONLoader", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.JSONLoader;
+  }
+});
+Object.defineProperty(exports, "NullLoader", {
+  enumerable: true,
+  get: function get() {
+    return _nullLoader.NullLoader;
+  }
+});
+Object.defineProperty(exports, "NullWorkerLoader", {
+  enumerable: true,
+  get: function get() {
+    return _nullLoader.NullWorkerLoader;
+  }
+});
+Object.defineProperty(exports, "RequestScheduler", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.RequestScheduler;
+  }
+});
+Object.defineProperty(exports, "_BrowserFileSystem", {
+  enumerable: true,
+  get: function get() {
+    return _browserFilesystem.default;
+  }
+});
+Object.defineProperty(exports, "_fetchProgress", {
+  enumerable: true,
+  get: function get() {
+    return _fetchProgress.default;
+  }
+});
+Object.defineProperty(exports, "_unregisterLoaders", {
+  enumerable: true,
+  get: function get() {
+    return _registerLoaders._unregisterLoaders;
+  }
+});
+Object.defineProperty(exports, "assert", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.assert;
+  }
+});
+Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.concatenateArrayBuffersAsync;
+  }
+});
+Object.defineProperty(exports, "document", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.document;
+  }
+});
+Object.defineProperty(exports, "encode", {
+  enumerable: true,
+  get: function get() {
+    return _encode.encode;
+  }
+});
+Object.defineProperty(exports, "encodeInBatches", {
+  enumerable: true,
+  get: function get() {
+    return _encode.encodeInBatches;
+  }
+});
+Object.defineProperty(exports, "encodeSync", {
+  enumerable: true,
+  get: function get() {
+    return _encode.encodeSync;
+  }
+});
+Object.defineProperty(exports, "encodeTable", {
+  enumerable: true,
+  get: function get() {
+    return _encodeTable.encodeTable;
+  }
+});
+Object.defineProperty(exports, "encodeTableAsText", {
+  enumerable: true,
+  get: function get() {
+    return _encodeTable.encodeTableAsText;
+  }
+});
+Object.defineProperty(exports, "encodeTableInBatches", {
+  enumerable: true,
+  get: function get() {
+    return _encodeTable.encodeTableInBatches;
+  }
+});
+Object.defineProperty(exports, "encodeText", {
+  enumerable: true,
+  get: function get() {
+    return _encode.encodeText;
+  }
+});
+Object.defineProperty(exports, "encodeURLtoURL", {
+  enumerable: true,
+  get: function get() {
+    return _encode.encodeURLtoURL;
+  }
+});
+Object.defineProperty(exports, "fetchFile", {
+  enumerable: true,
+  get: function get() {
+    return _fetchFile.fetchFile;
+  }
+});
+Object.defineProperty(exports, "forEach", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.forEach;
+  }
+});
+Object.defineProperty(exports, "getLoaderOptions", {
+  enumerable: true,
+  get: function get() {
+    return _loaderOptions.getLoaderOptions;
+  }
+});
+Object.defineProperty(exports, "getPathPrefix", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.getPathPrefix;
+  }
+});
+Object.defineProperty(exports, "global", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.global;
+  }
+});
+Object.defineProperty(exports, "isAsyncIterable", {
+  enumerable: true,
+  get: function get() {
+    return _isType.isAsyncIterable;
+  }
+});
+Object.defineProperty(exports, "isBrowser", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.isBrowser;
+  }
+});
+Object.defineProperty(exports, "isIterable", {
+  enumerable: true,
+  get: function get() {
+    return _isType.isIterable;
+  }
+});
+Object.defineProperty(exports, "isIterator", {
+  enumerable: true,
+  get: function get() {
+    return _isType.isIterator;
+  }
+});
+Object.defineProperty(exports, "isPromise", {
+  enumerable: true,
+  get: function get() {
+    return _isType.isPromise;
+  }
+});
+Object.defineProperty(exports, "isPureObject", {
+  enumerable: true,
+  get: function get() {
+    return _isType.isPureObject;
+  }
+});
+Object.defineProperty(exports, "isReadableStream", {
+  enumerable: true,
+  get: function get() {
+    return _isType.isReadableStream;
+  }
+});
+Object.defineProperty(exports, "isResponse", {
+  enumerable: true,
+  get: function get() {
+    return _isType.isResponse;
+  }
+});
+Object.defineProperty(exports, "isWorker", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.isWorker;
+  }
+});
+Object.defineProperty(exports, "isWritableStream", {
+  enumerable: true,
+  get: function get() {
+    return _isType.isWritableStream;
+  }
+});
+Object.defineProperty(exports, "load", {
+  enumerable: true,
+  get: function get() {
+    return _load.load;
+  }
+});
+Object.defineProperty(exports, "loadInBatches", {
+  enumerable: true,
+  get: function get() {
+    return _loadInBatches.loadInBatches;
+  }
+});
+Object.defineProperty(exports, "makeIterator", {
+  enumerable: true,
+  get: function get() {
+    return _makeIterator.makeIterator;
+  }
+});
+Object.defineProperty(exports, "makeLineIterator", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.makeLineIterator;
+  }
+});
+Object.defineProperty(exports, "makeNumberedLineIterator", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.makeNumberedLineIterator;
+  }
+});
+Object.defineProperty(exports, "makeStream", {
+  enumerable: true,
+  get: function get() {
+    return _makeNodeStream.makeStream;
+  }
+});
+Object.defineProperty(exports, "makeTextDecoderIterator", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.makeTextDecoderIterator;
+  }
+});
+Object.defineProperty(exports, "makeTextEncoderIterator", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.makeTextEncoderIterator;
+  }
+});
+Object.defineProperty(exports, "parse", {
+  enumerable: true,
+  get: function get() {
+    return _parse.parse;
+  }
+});
+Object.defineProperty(exports, "parseInBatches", {
+  enumerable: true,
+  get: function get() {
+    return _parseInBatches.parseInBatches;
+  }
+});
+Object.defineProperty(exports, "parseSync", {
+  enumerable: true,
+  get: function get() {
+    return _parseSync.parseSync;
+  }
+});
+Object.defineProperty(exports, "readArrayBuffer", {
+  enumerable: true,
+  get: function get() {
+    return _readArrayBuffer.readArrayBuffer;
+  }
+});
+Object.defineProperty(exports, "readFileSync", {
+  enumerable: true,
+  get: function get() {
+    return _readFile.readFileSync;
+  }
+});
+Object.defineProperty(exports, "registerLoaders", {
+  enumerable: true,
+  get: function get() {
+    return _registerLoaders.registerLoaders;
+  }
+});
+Object.defineProperty(exports, "resolvePath", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.resolvePath;
+  }
+});
+Object.defineProperty(exports, "save", {
+  enumerable: true,
+  get: function get() {
+    return _save.save;
+  }
+});
+Object.defineProperty(exports, "saveSync", {
+  enumerable: true,
+  get: function get() {
+    return _save.saveSync;
+  }
+});
+Object.defineProperty(exports, "selectLoader", {
+  enumerable: true,
+  get: function get() {
+    return _selectLoader.selectLoader;
+  }
+});
+Object.defineProperty(exports, "selectLoaderSync", {
+  enumerable: true,
+  get: function get() {
+    return _selectLoader.selectLoaderSync;
+  }
+});
+Object.defineProperty(exports, "self", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.self;
+  }
+});
+Object.defineProperty(exports, "setLoaderOptions", {
+  enumerable: true,
+  get: function get() {
+    return _loaderOptions.setLoaderOptions;
+  }
+});
+Object.defineProperty(exports, "setPathPrefix", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.setPathPrefix;
+  }
+});
+Object.defineProperty(exports, "window", {
+  enumerable: true,
+  get: function get() {
+    return _loaderUtils.window;
+  }
+});
+Object.defineProperty(exports, "writeFile", {
+  enumerable: true,
+  get: function get() {
+    return _writeFile.writeFile;
+  }
+});
+Object.defineProperty(exports, "writeFileSync", {
+  enumerable: true,
+  get: function get() {
+    return _writeFile.writeFileSync;
+  }
+});
+var _fetchFile = require("./lib/fetch/fetch-file");
+var _readArrayBuffer = require("./lib/fetch/read-array-buffer");
+var _readFile = require("./lib/fetch/read-file");
+var _writeFile = require("./lib/fetch/write-file");
+var _loaderOptions = require("./lib/api/loader-options");
+var _registerLoaders = require("./lib/api/register-loaders");
+var _selectLoader = require("./lib/api/select-loader");
+var _parse = require("./lib/api/parse");
+var _parseSync = require("./lib/api/parse-sync");
+var _parseInBatches = require("./lib/api/parse-in-batches");
+var _load = require("./lib/api/load");
+var _loadInBatches = require("./lib/api/load-in-batches");
+var _encodeTable = require("./lib/api/encode-table");
+var _encode = require("./lib/api/encode");
+var _save = require("./lib/api/save");
+var _loaderUtils = require("@loaders.gl/loader-utils");
+var _makeIterator = require("./iterators/make-iterator/make-iterator");
+var _makeNodeStream = require("./iterators/make-stream/make-node-stream");
+var _nullLoader = require("./null-loader");
+var _fetchProgress = _interopRequireDefault(require("./lib/progress/fetch-progress"));
+var _browserFilesystem = _interopRequireDefault(require("./lib/filesystems/browser-filesystem"));
+var _isType = require("./javascript-utils/is-type");
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_fetchFile","require","_readArrayBuffer","_readFile","_writeFile","_loaderOptions","_registerLoaders","_selectLoader","_parse","_parseSync","_parseInBatches","_load","_loadInBatches","_encodeTable","_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 {encodeTable, encodeTableAsText, encodeTableInBatches} from './lib/api/encode-table';\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,YAAA,GAAAZ,OAAA;AACA,IAAAa,OAAA,GAAAb,OAAA;AACA,IAAAc,KAAA,GAAAd,OAAA;AAGA,IAAAe,YAAA,GAAAf,OAAA;AAIA,IAAAgB,aAAA,GAAAhB,OAAA;AACA,IAAAiB,eAAA,GAAAjB,OAAA;AAGA,IAAAkB,WAAA,GAAAlB,OAAA;AAIA,IAAAmB,cAAA,GAAAC,sBAAA,CAAApB,OAAA;AACA,IAAAqB,kBAAA,GAAAD,sBAAA,CAAApB,OAAA;AAqBA,IAAAsB,OAAA,GAAAtB,OAAA"}

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

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.timedBatchIterator = timedBatchIterator;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+function _asyncIterator(iterable) { var method, async, sync, retry = 2; for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) { if (async && null != (method = iterable[async])) return method.call(iterable); if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable)); async = "@@asyncIterator", sync = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
+function AsyncFromSyncIterator(s) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var done = r.done; return Promise.resolve(r.value).then(function (value) { return { value: value, done: done }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) { this.s = s, this.n = s.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(value) { var ret = this.s.return; return void 0 === ret ? Promise.resolve({ value: value, done: !0 }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments)); }, throw: function _throw(value) { var thr = this.s.return; return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(s); }
+function timedBatchIterator(_x, _x2) {
+  return _timedBatchIterator.apply(this, arguments);
+}
+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;
+          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;
+            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;
+            break;
+          }
+          _context.next = 38;
+          return batches;
+        case 38:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[4, 21, 25, 35], [26,, 30, 34]]);
+  }));
+  return _timedBatchIterator.apply(this, arguments);
+}
+//# sourceMappingURL=timed-batch-iterator.js.map

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

@@ -0,0 +1 @@
+{"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,CAAC,CAAC;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,CAAC,CAAC,GAAGd,KAAK,GAAGD,OAAO;YAAAW,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAC9B,OAAMX,OAAO;QAAA;UACbD,KAAK,GAAGa,IAAI,CAACC,GAAG,CAAC,CAAC;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

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeArrayBufferIterator = makeArrayBufferIterator;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var DEFAULT_CHUNK_SIZE = 256 * 1024;
+function makeArrayBufferIterator(arrayBuffer) {
+  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$chunkSize = options.chunkSize, chunkSize = _options$chunkSize === void 0 ? DEFAULT_CHUNK_SIZE : _options$chunkSize;
+          byteOffset = 0;
+        case 2:
+          if (!(byteOffset < arrayBuffer.byteLength)) {
+            _context.next = 13;
+            break;
+          }
+          chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);
+          chunk = new ArrayBuffer(chunkByteLength);
+          sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);
+          chunkArray = new Uint8Array(chunk);
+          chunkArray.set(sourceArray);
+          byteOffset += chunkByteLength;
+          _context.next = 11;
+          return chunk;
+        case 11:
+          _context.next = 2;
+          break;
+        case 13:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })();
+}
+//# sourceMappingURL=make-array-buffer-iterator.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeBlobIterator = makeBlobIterator;
+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);
+}
+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;
+          break;
+        case 12:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _makeBlobIterator.apply(this, arguments);
+}
+//# sourceMappingURL=make-blob-iterator.js.map

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

@@ -0,0 +1 @@
+{"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,CAAC,CAAC;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"}

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

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeIterator = makeIterator;
+var _makeStringIterator = require("./make-string-iterator");
+var _makeArrayBufferIterator = require("./make-array-buffer-iterator");
+var _makeBlobIterator = require("./make-blob-iterator");
+var _makeStreamIterator = require("./make-stream-iterator");
+var _isType = require("../../javascript-utils/is-type");
+function makeIterator(data, options) {
+  if (typeof data === 'string') {
+    return (0, _makeStringIterator.makeStringIterator)(data, options);
+  }
+  if (data instanceof ArrayBuffer) {
+    return (0, _makeArrayBufferIterator.makeArrayBufferIterator)(data, options);
+  }
+  if ((0, _isType.isBlob)(data)) {
+    return (0, _makeBlobIterator.makeBlobIterator)(data, options);
+  }
+  if ((0, _isType.isReadableStream)(data)) {
+    return (0, _makeStreamIterator.makeStreamIterator)(data, options);
+  }
+  if ((0, _isType.isResponse)(data)) {
+    var response = data;
+    return (0, _makeStreamIterator.makeStreamIterator)(response.body, options);
+  }
+  throw new Error('makeIterator');
+}
+//# sourceMappingURL=make-iterator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"make-iterator.js","names":["_makeStringIterator","require","_makeArrayBufferIterator","_makeBlobIterator","_makeStreamIterator","_isType","makeIterator","data","options","makeStringIterator","ArrayBuffer","makeArrayBufferIterator","isBlob","makeBlobIterator","isReadableStream","makeStreamIterator","isResponse","response","body","Error"],"sources":["../../../../src/iterators/make-iterator/make-iterator.ts"],"sourcesContent":["import type {ReadStream} from 'fs';\n\nimport {makeStringIterator} from './make-string-iterator';\nimport {makeArrayBufferIterator} from './make-array-buffer-iterator';\nimport {makeBlobIterator} from './make-blob-iterator';\nimport type {StreamIteratorOptions} from './make-stream-iterator';\nimport {makeStreamIterator} from './make-stream-iterator';\nimport {isBlob, isReadableStream, isResponse} from '../../javascript-utils/is-type';\n\n/**\n * @param [options.chunkSize]\n */\nexport type IteratorOptions = StreamIteratorOptions & {\n  chunkSize?: number;\n};\n\n/**\n * Returns an iterator that breaks its input into chunks and yields them one-by-one.\n * @param data\n * @param options\n * @returns\n * This function can e.g. be used to enable data sources that can only be read atomically\n * (such as `Blob` and `File` via `FileReader`) to still be parsed in batches.\n */\nexport function makeIterator(\n  data: ArrayBuffer | string | Blob | Response | ReadableStream | ReadStream,\n  options?: IteratorOptions\n): AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer> {\n  if (typeof data === 'string') {\n    // Note: Converts string chunks to binary\n    return makeStringIterator(data, options);\n  }\n  if (data instanceof ArrayBuffer) {\n    return makeArrayBufferIterator(data, options);\n  }\n  if (isBlob(data)) {\n    return makeBlobIterator(data as Blob, options);\n  }\n  if (isReadableStream(data)) {\n    return makeStreamIterator(data as ReadableStream, options);\n  }\n  if (isResponse(data)) {\n    const response = data as Response;\n    return makeStreamIterator(response.body as ReadableStream, options);\n  }\n  throw new Error('makeIterator');\n}\n"],"mappings":";;;;;;AAEA,IAAAA,mBAAA,GAAAC,OAAA;AACA,IAAAC,wBAAA,GAAAD,OAAA;AACA,IAAAE,iBAAA,GAAAF,OAAA;AAEA,IAAAG,mBAAA,GAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AAiBO,SAASK,YAAYA,CAC1BC,IAA0E,EAC1EC,OAAyB,EAC2B;EACpD,IAAI,OAAOD,IAAI,KAAK,QAAQ,EAAE;IAE5B,OAAO,IAAAE,sCAAkB,EAACF,IAAI,EAAEC,OAAO,CAAC;EAC1C;EACA,IAAID,IAAI,YAAYG,WAAW,EAAE;IAC/B,OAAO,IAAAC,gDAAuB,EAACJ,IAAI,EAAEC,OAAO,CAAC;EAC/C;EACA,IAAI,IAAAI,cAAM,EAACL,IAAI,CAAC,EAAE;IAChB,OAAO,IAAAM,kCAAgB,EAACN,IAAI,EAAUC,OAAO,CAAC;EAChD;EACA,IAAI,IAAAM,wBAAgB,EAACP,IAAI,CAAC,EAAE;IAC1B,OAAO,IAAAQ,sCAAkB,EAACR,IAAI,EAAoBC,OAAO,CAAC;EAC5D;EACA,IAAI,IAAAQ,kBAAU,EAACT,IAAI,CAAC,EAAE;IACpB,IAAMU,QAAQ,GAAGV,IAAgB;IACjC,OAAO,IAAAQ,sCAAkB,EAACE,QAAQ,CAACC,IAAI,EAAoBV,OAAO,CAAC;EACrE;EACA,MAAM,IAAIW,KAAK,CAAC,cAAc,CAAC;AACjC"}