@loaders.gl/core 3.1.0-beta.6 → 3.1.2

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

@@ -1,20 +1,61 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.makeBlobIterator = makeBlobIterator;
-const DEFAULT_CHUNK_SIZE = 1024 * 1024;
-
-async function* makeBlobIterator(blob, options) {
-  const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
-  let offset = 0;
-
-  while (offset < blob.size) {
-    const end = offset + chunkSize;
-    const chunk = await blob.slice(offset, end).arrayBuffer();
-    offset = end;
-    yield chunk;
-  }
+
+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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/iterators/make-iterator/make-blob-iterator.ts"],"names":["DEFAULT_CHUNK_SIZE","makeBlobIterator","blob","options","chunkSize","offset","size","end","chunk","slice","arrayBuffer"],"mappings":";;;;;;AAEA,MAAMA,kBAAkB,GAAG,OAAO,IAAlC;;AAQO,gBAAgBC,gBAAhB,CACLC,IADK,EAELC,OAFK,EAGuB;AAC5B,QAAMC,SAAS,GAAG,CAAAD,OAAO,SAAP,IAAAA,OAAO,WAAP,YAAAA,OAAO,CAAEC,SAAT,KAAsBJ,kBAAxC;AAEA,MAAIK,MAAM,GAAG,CAAb;;AACA,SAAOA,MAAM,GAAGH,IAAI,CAACI,IAArB,EAA2B;AACzB,UAAMC,GAAG,GAAGF,MAAM,GAAGD,SAArB;AAEA,UAAMI,KAAK,GAAG,MAAMN,IAAI,CAACO,KAAL,CAAWJ,MAAX,EAAmBE,GAAnB,EAAwBG,WAAxB,EAApB;AAEAL,IAAAA,MAAM,GAAGE,GAAT;AACA,UAAMC,KAAN;AACD;AACF","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"],"file":"make-blob-iterator.js"}
+{"version":3,"sources":["../../../../src/iterators/make-iterator/make-blob-iterator.ts"],"names":["DEFAULT_CHUNK_SIZE","makeBlobIterator","blob","options","chunkSize","offset","size","end","slice","arrayBuffer","chunk"],"mappings":";;;;;;;;;;;;;;;AAEA,IAAMA,kBAAkB,GAAG,OAAO,IAAlC;;SAQuBC,gB;;;;;kFAAhB,iBACLC,IADK,EAELC,OAFK;AAAA;AAAA;AAAA;AAAA;AAAA;AAICC,YAAAA,SAJD,GAIa,CAAAD,OAAO,SAAP,IAAAA,OAAO,WAAP,YAAAA,OAAO,CAAEC,SAAT,KAAsBJ,kBAJnC;AAMDK,YAAAA,MANC,GAMQ,CANR;;AAAA;AAAA,kBAOEA,MAAM,GAAGH,IAAI,CAACI,IAPhB;AAAA;AAAA;AAAA;;AAQGC,YAAAA,GARH,GAQSF,MAAM,GAAGD,SARlB;AAAA;AAAA,sDAUiBF,IAAI,CAACM,KAAL,CAAWH,MAAX,EAAmBE,GAAnB,EAAwBE,WAAxB,EAVjB;;AAAA;AAUGC,YAAAA,KAVH;AAYHL,YAAAA,MAAM,GAAGE,GAAT;AAZG;AAaH,mBAAMG,KAAN;;AAbG;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","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"],"file":"make-blob-iterator.js"}

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

@@ -33,7 +33,7 @@ function makeIterator(data, options) {
   }
 
   if ((0, _isType.isResponse)(data)) {
-    const response = data;
+    var response = data;
     return (0, _makeStreamIterator.makeStreamIterator)(response.body, options);
   }
 

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/iterators/make-iterator/make-iterator.ts"],"names":["makeIterator","data","options","ArrayBuffer","response","body","Error"],"mappings":";;;;;;;AAEA;;AACA;;AACA;;AAEA;;AACA;;AAiBO,SAASA,YAAT,CACLC,IADK,EAELC,OAFK,EAG+C;AACpD,MAAI,OAAOD,IAAP,KAAgB,QAApB,EAA8B;AAE5B,WAAO,4CAAmBA,IAAnB,EAAyBC,OAAzB,CAAP;AACD;;AACD,MAAID,IAAI,YAAYE,WAApB,EAAiC;AAC/B,WAAO,sDAAwBF,IAAxB,EAA8BC,OAA9B,CAAP;AACD;;AACD,MAAI,oBAAOD,IAAP,CAAJ,EAAkB;AAChB,WAAO,wCAAiBA,IAAjB,EAA+BC,OAA/B,CAAP;AACD;;AACD,MAAI,8BAAiBD,IAAjB,CAAJ,EAA4B;AAC1B,WAAO,4CAAmBA,IAAnB,EAA2CC,OAA3C,CAAP;AACD;;AACD,MAAI,wBAAWD,IAAX,CAAJ,EAAsB;AACpB,UAAMG,QAAQ,GAAGH,IAAjB;AACA,WAAO,4CAAmBG,QAAQ,CAACC,IAA5B,EAAoDH,OAApD,CAAP;AACD;;AACD,QAAM,IAAII,KAAJ,CAAU,cAAV,CAAN;AACD","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"],"file":"make-iterator.js"}
+{"version":3,"sources":["../../../../src/iterators/make-iterator/make-iterator.ts"],"names":["makeIterator","data","options","ArrayBuffer","response","body","Error"],"mappings":";;;;;;;AAEA;;AACA;;AACA;;AAEA;;AACA;;AAiBO,SAASA,YAAT,CACLC,IADK,EAELC,OAFK,EAG+C;AACpD,MAAI,OAAOD,IAAP,KAAgB,QAApB,EAA8B;AAE5B,WAAO,4CAAmBA,IAAnB,EAAyBC,OAAzB,CAAP;AACD;;AACD,MAAID,IAAI,YAAYE,WAApB,EAAiC;AAC/B,WAAO,sDAAwBF,IAAxB,EAA8BC,OAA9B,CAAP;AACD;;AACD,MAAI,oBAAOD,IAAP,CAAJ,EAAkB;AAChB,WAAO,wCAAiBA,IAAjB,EAA+BC,OAA/B,CAAP;AACD;;AACD,MAAI,8BAAiBD,IAAjB,CAAJ,EAA4B;AAC1B,WAAO,4CAAmBA,IAAnB,EAA2CC,OAA3C,CAAP;AACD;;AACD,MAAI,wBAAWD,IAAX,CAAJ,EAAsB;AACpB,QAAMG,QAAQ,GAAGH,IAAjB;AACA,WAAO,4CAAmBG,QAAQ,CAACC,IAA5B,EAAoDH,OAApD,CAAP;AACD;;AACD,QAAM,IAAII,KAAJ,CAAU,cAAV,CAAN;AACD","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"],"file":"make-iterator.js"}

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

@@ -1,47 +1,184 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.makeStreamIterator = makeStreamIterator;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
 var _loaderUtils = require("@loaders.gl/loader-utils");
 
 function makeStreamIterator(stream, options) {
   return _loaderUtils.isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
 }
 
-async function* makeBrowserStreamIterator(stream, options) {
-  const reader = stream.getReader();
-  let nextBatchPromise;
+function makeBrowserStreamIterator(_x, _x2) {
+  return _makeBrowserStreamIterator.apply(this, arguments);
+}
 
-  try {
-    while (true) {
-      const currentBatchPromise = nextBatchPromise || reader.read();
+function _makeBrowserStreamIterator() {
+  _makeBrowserStreamIterator = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(stream, options) {
+    var reader, nextBatchPromise, currentBatchPromise, _yield$_awaitAsyncGen, done, value;
 
-      if (options !== null && options !== void 0 && options._streamReadAhead) {
-        nextBatchPromise = reader.read();
-      }
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            reader = stream.getReader();
+            _context.prev = 1;
+
+          case 2:
+            if (!true) {
+              _context.next = 16;
+              break;
+            }
+
+            currentBatchPromise = nextBatchPromise || reader.read();
+
+            if (options !== null && options !== void 0 && options._streamReadAhead) {
+              nextBatchPromise = reader.read();
+            }
 
-      const {
-        done,
-        value
-      } = await currentBatchPromise;
+            _context.next = 7;
+            return (0, _awaitAsyncGenerator2.default)(currentBatchPromise);
 
-      if (done) {
-        return;
+          case 7:
+            _yield$_awaitAsyncGen = _context.sent;
+            done = _yield$_awaitAsyncGen.done;
+            value = _yield$_awaitAsyncGen.value;
+
+            if (!done) {
+              _context.next = 12;
+              break;
+            }
+
+            return _context.abrupt("return");
+
+          case 12:
+            _context.next = 14;
+            return (0, _loaderUtils.toArrayBuffer)(value);
+
+          case 14:
+            _context.next = 2;
+            break;
+
+          case 16:
+            _context.next = 21;
+            break;
+
+          case 18:
+            _context.prev = 18;
+            _context.t0 = _context["catch"](1);
+            reader.releaseLock();
+
+          case 21:
+          case "end":
+            return _context.stop();
+        }
       }
+    }, _callee, null, [[1, 18]]);
+  }));
+  return _makeBrowserStreamIterator.apply(this, arguments);
+}
 
-      yield (0, _loaderUtils.toArrayBuffer)(value);
-    }
-  } catch (error) {
-    reader.releaseLock();
-  }
+function makeNodeStreamIterator(_x3, _x4) {
+  return _makeNodeStreamIterator.apply(this, arguments);
 }
 
-async function* makeNodeStreamIterator(stream, options) {
-  for await (const chunk of stream) {
-    yield (0, _loaderUtils.toArrayBuffer)(chunk);
-  }
+function _makeNodeStreamIterator() {
+  _makeNodeStreamIterator = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee2(stream, options) {
+    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _iteratorNormalCompletion = true;
+            _didIteratorError = false;
+            _context2.prev = 2;
+            _iterator = (0, _asyncIterator2.default)(stream);
+
+          case 4:
+            _context2.next = 6;
+            return (0, _awaitAsyncGenerator2.default)(_iterator.next());
+
+          case 6:
+            _step = _context2.sent;
+            _iteratorNormalCompletion = _step.done;
+            _context2.next = 10;
+            return (0, _awaitAsyncGenerator2.default)(_step.value);
+
+          case 10:
+            _value = _context2.sent;
+
+            if (_iteratorNormalCompletion) {
+              _context2.next = 18;
+              break;
+            }
+
+            chunk = _value;
+            _context2.next = 15;
+            return (0, _loaderUtils.toArrayBuffer)(chunk);
+
+          case 15:
+            _iteratorNormalCompletion = true;
+            _context2.next = 4;
+            break;
+
+          case 18:
+            _context2.next = 24;
+            break;
+
+          case 20:
+            _context2.prev = 20;
+            _context2.t0 = _context2["catch"](2);
+            _didIteratorError = true;
+            _iteratorError = _context2.t0;
+
+          case 24:
+            _context2.prev = 24;
+            _context2.prev = 25;
+
+            if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
+              _context2.next = 29;
+              break;
+            }
+
+            _context2.next = 29;
+            return (0, _awaitAsyncGenerator2.default)(_iterator.return());
+
+          case 29:
+            _context2.prev = 29;
+
+            if (!_didIteratorError) {
+              _context2.next = 32;
+              break;
+            }
+
+            throw _iteratorError;
+
+          case 32:
+            return _context2.finish(29);
+
+          case 33:
+            return _context2.finish(24);
+
+          case 34:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[2, 20, 24, 34], [25,, 29, 33]]);
+  }));
+  return _makeNodeStreamIterator.apply(this, arguments);
 }
 //# sourceMappingURL=make-stream-iterator.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/iterators/make-iterator/make-stream-iterator.ts"],"names":["makeStreamIterator","stream","options","isBrowser","makeBrowserStreamIterator","makeNodeStreamIterator","reader","getReader","nextBatchPromise","currentBatchPromise","read","_streamReadAhead","done","value","error","releaseLock","chunk"],"mappings":";;;;;;;AACA;;AAUO,SAASA,kBAAT,CACLC,MADK,EAELC,OAFK,EAGuB;AAC5B,SAAOC,yBACHC,yBAAyB,CAACH,MAAD,EAA2BC,OAA3B,CADtB,GAEHG,sBAAsB,CAACJ,MAAD,EAAqBC,OAArB,CAF1B;AAGD;;AAOD,gBAAgBE,yBAAhB,CACEH,MADF,EAEEC,OAFF,EAG8B;AAU5B,QAAMI,MAAM,GAAGL,MAAM,CAACM,SAAP,EAAf;AAEA,MAAIC,gBAAJ;;AAEA,MAAI;AAEF,WAAO,IAAP,EAAa;AACX,YAAMC,mBAAmB,GAAGD,gBAAgB,IAAIF,MAAM,CAACI,IAAP,EAAhD;;AAGA,UAAIR,OAAJ,aAAIA,OAAJ,eAAIA,OAAO,CAAES,gBAAb,EAA+B;AAC7BH,QAAAA,gBAAgB,GAAGF,MAAM,CAACI,IAAP,EAAnB;AACD;;AAGD,YAAM;AAACE,QAAAA,IAAD;AAAOC,QAAAA;AAAP,UAAgB,MAAMJ,mBAA5B;;AAEA,UAAIG,IAAJ,EAAU;AACR;AACD;;AAED,YAAM,gCAAcC,KAAd,CAAN;AACD;AACF,GAnBD,CAmBE,OAAOC,KAAP,EAAc;AAGdR,IAAAA,MAAM,CAACS,WAAP;AACD;AACF;;AAOD,gBAAgBV,sBAAhB,CACEJ,MADF,EAEEC,OAFF,EAG8B;AAG5B,aAAW,MAAMc,KAAjB,IAA0Bf,MAA1B,EAAkC;AAChC,UAAM,gCAAce,KAAd,CAAN;AACD;AACF","sourcesContent":["import type {Readable} from 'stream';\nimport {isBrowser, toArrayBuffer} from '@loaders.gl/loader-utils';\n\nexport type StreamIteratorOptions = {\n  _streamReadAhead?: boolean;\n};\n\n/**\n * Returns an async iterable that reads from a stream (works in both Node.js and browsers)\n * @param stream stream to iterator over\n */\nexport function makeStreamIterator(\n  stream: ReadableStream | Readable,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  return isBrowser\n    ? makeBrowserStreamIterator(stream as ReadableStream, options)\n    : makeNodeStreamIterator(stream as Readable, options);\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @see https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate\n */\nasync function* makeBrowserStreamIterator(\n  stream: ReadableStream,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  // WhatWG: stream is supposed to have a `getIterator` method\n  // if (typeof stream.getIterator === 'function') {\n  //   return stream.getIterator();\n  // }\n  // if (typeof stream[Symbol.asyncIterator] === 'function') {\n  //   return makeToArrayBufferIterator(stream);\n  // }\n\n  // In the browser, we first need to get a lock on the stream\n  const reader = stream.getReader();\n\n  let nextBatchPromise: Promise<{done?: boolean; value?: Uint8Array}> | undefined;\n\n  try {\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n      const currentBatchPromise = nextBatchPromise || reader.read();\n      // Issue a read for an additional batch, while we await the next batch\n      // Idea is to make fetching happen in parallel with processing / parsing\n      if (options?._streamReadAhead) {\n        nextBatchPromise = reader.read();\n      }\n      // Read from the stream\n      // value is a Uint8Array\n      const {done, value} = await currentBatchPromise;\n      // Exit if we're done\n      if (done) {\n        return;\n      }\n      // Else yield the chunk\n      yield toArrayBuffer(value);\n    }\n  } catch (error) {\n    // TODO - examples makes it look like this should always be called,\n    // but that generates exceptions so only call it if we do not reach the end\n    reader.releaseLock();\n  }\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @note Requires Node.js >= 10\n */\nasync function* makeNodeStreamIterator(\n  stream: Readable,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  // Hacky test for node version to ensure we don't call bad polyfills\n  // NODE 10+: stream is an asyncIterator\n  for await (const chunk of stream) {\n    yield toArrayBuffer(chunk); // Coerce each chunk to ArrayBuffer\n  }\n}\n/* TODO - remove NODE < 10\n * @see https://github.com/bustle/streaming-iterables, MIT license\n *\n  if (typeof stream[Symbol.asyncIterator] === 'function') {\n    return;\n  }\n\n  // TODO - check if is this ever used in Node 10+?\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    const data = stream.read();\n    if (data !== null) {\n      yield toArrayBuffer(data);\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n    if (stream._readableState?.ended) {\n      return;\n    }\n    await onceReadable(stream);\n  }\n\nasync function onceReadable(stream: Readable): Promise<any> {\n  return new Promise((resolve) => {\n    stream.once('readable', resolve);\n  });\n}\n  */\n"],"file":"make-stream-iterator.js"}
+{"version":3,"sources":["../../../../src/iterators/make-iterator/make-stream-iterator.ts"],"names":["makeStreamIterator","stream","options","isBrowser","makeBrowserStreamIterator","makeNodeStreamIterator","reader","getReader","currentBatchPromise","nextBatchPromise","read","_streamReadAhead","done","value","releaseLock","chunk"],"mappings":";;;;;;;;;;;;;;;;;AACA;;AAUO,SAASA,kBAAT,CACLC,MADK,EAELC,OAFK,EAGuB;AAC5B,SAAOC,yBACHC,yBAAyB,CAACH,MAAD,EAA2BC,OAA3B,CADtB,GAEHG,sBAAsB,CAACJ,MAAD,EAAqBC,OAArB,CAF1B;AAGD;;SAOeE,yB;;;;;2FAAhB,iBACEH,MADF,EAEEC,OAFF;AAAA;;AAAA;AAAA;AAAA;AAAA;AAaQI,YAAAA,MAbR,GAaiBL,MAAM,CAACM,SAAP,EAbjB;AAAA;;AAAA;AAAA,iBAmBW,IAnBX;AAAA;AAAA;AAAA;;AAoBYC,YAAAA,mBApBZ,GAoBkCC,gBAAgB,IAAIH,MAAM,CAACI,IAAP,EApBtD;;AAuBM,gBAAIR,OAAJ,aAAIA,OAAJ,eAAIA,OAAO,CAAES,gBAAb,EAA+B;AAC7BF,cAAAA,gBAAgB,GAAGH,MAAM,CAACI,IAAP,EAAnB;AACD;;AAzBP;AAAA,sDA4BkCF,mBA5BlC;;AAAA;AAAA;AA4BaI,YAAAA,IA5Bb,yBA4BaA,IA5Bb;AA4BmBC,YAAAA,KA5BnB,yBA4BmBA,KA5BnB;;AAAA,iBA8BUD,IA9BV;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;AAkCM,mBAAM,gCAAcC,KAAd,CAAN;;AAlCN;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAuCIP,YAAAA,MAAM,CAACQ,WAAP;;AAvCJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAgDgBT,sB;;;;;wFAAhB,kBACEJ,MADF,EAEEC,OAFF;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qDAM4BD,MAN5B;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAMmBc,YAAAA,KANnB;AAAA;AAOI,mBAAM,gCAAcA,KAAd,CAAN;;AAPJ;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["import type {Readable} from 'stream';\nimport {isBrowser, toArrayBuffer} from '@loaders.gl/loader-utils';\n\nexport type StreamIteratorOptions = {\n  _streamReadAhead?: boolean;\n};\n\n/**\n * Returns an async iterable that reads from a stream (works in both Node.js and browsers)\n * @param stream stream to iterator over\n */\nexport function makeStreamIterator(\n  stream: ReadableStream | Readable,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  return isBrowser\n    ? makeBrowserStreamIterator(stream as ReadableStream, options)\n    : makeNodeStreamIterator(stream as Readable, options);\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @see https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate\n */\nasync function* makeBrowserStreamIterator(\n  stream: ReadableStream,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  // WhatWG: stream is supposed to have a `getIterator` method\n  // if (typeof stream.getIterator === 'function') {\n  //   return stream.getIterator();\n  // }\n  // if (typeof stream[Symbol.asyncIterator] === 'function') {\n  //   return makeToArrayBufferIterator(stream);\n  // }\n\n  // In the browser, we first need to get a lock on the stream\n  const reader = stream.getReader();\n\n  let nextBatchPromise: Promise<{done?: boolean; value?: Uint8Array}> | undefined;\n\n  try {\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n      const currentBatchPromise = nextBatchPromise || reader.read();\n      // Issue a read for an additional batch, while we await the next batch\n      // Idea is to make fetching happen in parallel with processing / parsing\n      if (options?._streamReadAhead) {\n        nextBatchPromise = reader.read();\n      }\n      // Read from the stream\n      // value is a Uint8Array\n      const {done, value} = await currentBatchPromise;\n      // Exit if we're done\n      if (done) {\n        return;\n      }\n      // Else yield the chunk\n      yield toArrayBuffer(value);\n    }\n  } catch (error) {\n    // TODO - examples makes it look like this should always be called,\n    // but that generates exceptions so only call it if we do not reach the end\n    reader.releaseLock();\n  }\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @note Requires Node.js >= 10\n */\nasync function* makeNodeStreamIterator(\n  stream: Readable,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  // Hacky test for node version to ensure we don't call bad polyfills\n  // NODE 10+: stream is an asyncIterator\n  for await (const chunk of stream) {\n    yield toArrayBuffer(chunk); // Coerce each chunk to ArrayBuffer\n  }\n}\n/* TODO - remove NODE < 10\n * @see https://github.com/bustle/streaming-iterables, MIT license\n *\n  if (typeof stream[Symbol.asyncIterator] === 'function') {\n    return;\n  }\n\n  // TODO - check if is this ever used in Node 10+?\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    const data = stream.read();\n    if (data !== null) {\n      yield toArrayBuffer(data);\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n    if (stream._readableState?.ended) {\n      return;\n    }\n    await onceReadable(stream);\n  }\n\nasync function onceReadable(stream: Readable): Promise<any> {\n  return new Promise((resolve) => {\n    stream.once('readable', resolve);\n  });\n}\n  */\n"],"file":"make-stream-iterator.js"}

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

@@ -1,21 +1,49 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.makeStringIterator = makeStringIterator;
-const DEFAULT_CHUNK_SIZE = 256 * 1024;
-
-function* makeStringIterator(string, options) {
-  const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
-  let offset = 0;
-  const textEncoder = new TextEncoder();
-
-  while (offset < string.length) {
-    const chunkLength = Math.min(string.length - offset, chunkSize);
-    const chunk = string.slice(offset, offset + chunkLength);
-    offset += chunkLength;
-    yield textEncoder.encode(chunk);
-  }
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _marked = _regenerator.default.mark(makeStringIterator);
+
+var DEFAULT_CHUNK_SIZE = 256 * 1024;
+
+function makeStringIterator(string, options) {
+  var chunkSize, offset, textEncoder, chunkLength, chunk;
+  return _regenerator.default.wrap(function makeStringIterator$(_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;
+          textEncoder = new TextEncoder();
+
+        case 3:
+          if (!(offset < string.length)) {
+            _context.next = 11;
+            break;
+          }
+
+          chunkLength = Math.min(string.length - offset, chunkSize);
+          chunk = string.slice(offset, offset + chunkLength);
+          offset += chunkLength;
+          _context.next = 9;
+          return textEncoder.encode(chunk);
+
+        case 9:
+          _context.next = 3;
+          break;
+
+        case 11:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked);
 }
 //# sourceMappingURL=make-string-iterator.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/iterators/make-iterator/make-string-iterator.ts"],"names":["DEFAULT_CHUNK_SIZE","makeStringIterator","string","options","chunkSize","offset","textEncoder","TextEncoder","length","chunkLength","Math","min","chunk","slice","encode"],"mappings":";;;;;;AAEA,MAAMA,kBAAkB,GAAG,MAAM,IAAjC;;AAQO,UAAUC,kBAAV,CACLC,MADK,EAELC,OAFK,EAGkB;AACvB,QAAMC,SAAS,GAAG,CAAAD,OAAO,SAAP,IAAAA,OAAO,WAAP,YAAAA,OAAO,CAAEC,SAAT,KAAsBJ,kBAAxC;AAEA,MAAIK,MAAM,GAAG,CAAb;AACA,QAAMC,WAAW,GAAG,IAAIC,WAAJ,EAApB;;AACA,SAAOF,MAAM,GAAGH,MAAM,CAACM,MAAvB,EAA+B;AAE7B,UAAMC,WAAW,GAAGC,IAAI,CAACC,GAAL,CAAST,MAAM,CAACM,MAAP,GAAgBH,MAAzB,EAAiCD,SAAjC,CAApB;AACA,UAAMQ,KAAK,GAAGV,MAAM,CAACW,KAAP,CAAaR,MAAb,EAAqBA,MAAM,GAAGI,WAA9B,CAAd;AACAJ,IAAAA,MAAM,IAAII,WAAV;AAGA,UAAMH,WAAW,CAACQ,MAAZ,CAAmBF,KAAnB,CAAN;AACD;AACF","sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 256 * 1024;\n\n/**\n * Returns an iterator that breaks a big string into chunks and yields them one-by-one as ArrayBuffers\n * @param blob string to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeStringIterator(\n  string: string,\n  options?: IteratorOptions\n): Iterable<ArrayBuffer> {\n  const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n  let offset = 0;\n  const textEncoder = new TextEncoder();\n  while (offset < string.length) {\n    // Create a chunk of the right size\n    const chunkLength = Math.min(string.length - offset, chunkSize);\n    const chunk = string.slice(offset, offset + chunkLength);\n    offset += chunkLength;\n\n    // yield an ArrayBuffer chunk\n    yield textEncoder.encode(chunk);\n  }\n}\n"],"file":"make-string-iterator.js"}
+{"version":3,"sources":["../../../../src/iterators/make-iterator/make-string-iterator.ts"],"names":["makeStringIterator","DEFAULT_CHUNK_SIZE","string","options","chunkSize","offset","textEncoder","TextEncoder","length","chunkLength","Math","min","chunk","slice","encode"],"mappings":";;;;;;;;;;;wCAUiBA,kB;;AARjB,IAAMC,kBAAkB,GAAG,MAAM,IAAjC;;AAQO,SAAUD,kBAAV,CACLE,MADK,EAELC,OAFK;AAAA;AAAA;AAAA;AAAA;AAAA;AAICC,UAAAA,SAJD,GAIa,CAAAD,OAAO,SAAP,IAAAA,OAAO,WAAP,YAAAA,OAAO,CAAEC,SAAT,KAAsBH,kBAJnC;AAMDI,UAAAA,MANC,GAMQ,CANR;AAOCC,UAAAA,WAPD,GAOe,IAAIC,WAAJ,EAPf;;AAAA;AAAA,gBAQEF,MAAM,GAAGH,MAAM,CAACM,MARlB;AAAA;AAAA;AAAA;;AAUGC,UAAAA,WAVH,GAUiBC,IAAI,CAACC,GAAL,CAAST,MAAM,CAACM,MAAP,GAAgBH,MAAzB,EAAiCD,SAAjC,CAVjB;AAWGQ,UAAAA,KAXH,GAWWV,MAAM,CAACW,KAAP,CAAaR,MAAb,EAAqBA,MAAM,GAAGI,WAA9B,CAXX;AAYHJ,UAAAA,MAAM,IAAII,WAAV;AAZG;AAeH,iBAAMH,WAAW,CAACQ,MAAZ,CAAmBF,KAAnB,CAAN;;AAfG;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA","sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 256 * 1024;\n\n/**\n * Returns an iterator that breaks a big string into chunks and yields them one-by-one as ArrayBuffers\n * @param blob string to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeStringIterator(\n  string: string,\n  options?: IteratorOptions\n): Iterable<ArrayBuffer> {\n  const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n  let offset = 0;\n  const textEncoder = new TextEncoder();\n  while (offset < string.length) {\n    // Create a chunk of the right size\n    const chunkLength = Math.min(string.length - offset, chunkSize);\n    const chunk = string.slice(offset, offset + chunkLength);\n    offset += chunkLength;\n\n    // yield an ArrayBuffer chunk\n    yield textEncoder.encode(chunk);\n  }\n}\n"],"file":"make-string-iterator.js"}

package/dist/es5/iterators/make-stream/make-dom-stream.js

@@ -1,41 +1,86 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.makeDOMStream = makeDOMStream;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 function makeDOMStream(source, options) {
-  const iterator = source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
+  var iterator = source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
   return new ReadableStream({
     type: 'bytes',
+    pull: function pull(controller) {
+      return (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+        var _yield$iterator$next, done, value;
 
-    async pull(controller) {
-      try {
-        const {
-          done,
-          value
-        } = await iterator.next();
-
-        if (done) {
-          controller.close();
-        } else {
-          controller.enqueue(new Uint8Array(value));
-        }
-      } catch (error) {
-        controller.error(error);
-      }
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.prev = 0;
+                _context.next = 3;
+                return iterator.next();
+
+              case 3:
+                _yield$iterator$next = _context.sent;
+                done = _yield$iterator$next.done;
+                value = _yield$iterator$next.value;
+
+                if (done) {
+                  controller.close();
+                } else {
+                  controller.enqueue(new Uint8Array(value));
+                }
+
+                _context.next = 12;
+                break;
+
+              case 9:
+                _context.prev = 9;
+                _context.t0 = _context["catch"](0);
+                controller.error(_context.t0);
+
+              case 12:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[0, 9]]);
+      }))();
     },
+    cancel: function cancel() {
+      return (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2() {
+        var _iterator$return;
 
-    async cancel() {
-      var _iterator$return;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return iterator === null || iterator === void 0 ? void 0 : (_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator);
 
-      await (iterator === null || iterator === void 0 ? void 0 : (_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator));
+              case 2:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }))();
     }
-
-  }, {
-    highWaterMark: 2 ** 24,
-    ...options
-  });
+  }, _objectSpread({
+    highWaterMark: Math.pow(2, 24)
+  }, options));
 }
 //# sourceMappingURL=make-dom-stream.js.map

package/dist/es5/iterators/make-stream/make-dom-stream.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/iterators/make-stream/make-dom-stream.ts"],"names":["makeDOMStream","source","options","iterator","Symbol","asyncIterator","ReadableStream","type","pull","controller","done","value","next","close","enqueue","Uint8Array","error","cancel","return","highWaterMark"],"mappings":";;;;;;;AAQO,SAASA,aAAT,CACLC,MADK,EAELC,OAFK,EAGW;AAChB,QAAMC,QAAQ,GAAGF,MAAM,CAACG,MAAM,CAACC,aAAR,CAAN,GACZJ,MAAD,CAAuCG,MAAM,CAACC,aAA9C,GADa,GAEZJ,MAAD,CAAkCG,MAAM,CAACD,QAAzC,GAFJ;AAIA,SAAO,IAAIG,cAAJ,CACL;AAKEC,IAAAA,IAAI,EAAE,OALR;;AAOE,UAAMC,IAAN,CAAWC,UAAX,EAAuB;AACrB,UAAI;AACF,cAAM;AAACC,UAAAA,IAAD;AAAOC,UAAAA;AAAP,YAAgB,MAAMR,QAAQ,CAACS,IAAT,EAA5B;;AACA,YAAIF,IAAJ,EAAU;AACRD,UAAAA,UAAU,CAACI,KAAX;AACD,SAFD,MAEO;AAELJ,UAAAA,UAAU,CAACK,OAAX,CAAmB,IAAIC,UAAJ,CAAeJ,KAAf,CAAnB;AACD;AACF,OARD,CAQE,OAAOK,KAAP,EAAc;AACdP,QAAAA,UAAU,CAACO,KAAX,CAAiBA,KAAjB;AACD;AACF,KAnBH;;AAqBE,UAAMC,MAAN,GAAe;AAAA;;AACb,aAAMd,QAAN,aAAMA,QAAN,2CAAMA,QAAQ,CAAEe,MAAhB,qDAAM,sBAAAf,QAAQ,CAAd;AACD;;AAvBH,GADK,EA2BL;AAEEgB,IAAAA,aAAa,EAAE,KAAK,EAFtB;AAGE,OAAGjB;AAHL,GA3BK,CAAP;AAiCD","sourcesContent":["export type MakeDOMStreamOptions = {\n  /** Stream allocates an arrayBuffer. Enables use of a default reader. */\n  autoAllocateChunkSize?: number;\n  /** Total number of chunks in queue before back pressure is applied */\n  highWaterMark?: number;\n};\n\n/** Builds a DOM stream from an iterator */\nexport function makeDOMStream<ArrayBuffer>(\n  source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,\n  options?: MakeDOMStreamOptions\n): ReadableStream {\n  const iterator = source[Symbol.asyncIterator]\n    ? (source as AsyncIterable<ArrayBuffer>)[Symbol.asyncIterator]()\n    : (source as Iterable<ArrayBuffer>)[Symbol.iterator]();\n\n  return new ReadableStream<Uint8Array>(\n    {\n      // Create a byte stream (enables `Response(stream).arrayBuffer()`)\n      // Only supported on Chrome\n      // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController\n      // @ts-expect-error Only Chrome supports byte streams\n      type: 'bytes',\n\n      async pull(controller) {\n        try {\n          const {done, value} = await iterator.next();\n          if (done) {\n            controller.close();\n          } else {\n            // TODO - ignores controller.desiredSize\n            controller.enqueue(new Uint8Array(value));\n          }\n        } catch (error) {\n          controller.error(error);\n        }\n      },\n\n      async cancel() {\n        await iterator?.return?.();\n      }\n    },\n    // options: QueingStrategy<Uint8Array>\n    {\n      // This is bytes, not chunks\n      highWaterMark: 2 ** 24,\n      ...options\n    }\n  );\n}\n"],"file":"make-dom-stream.js"}
+{"version":3,"sources":["../../../../src/iterators/make-stream/make-dom-stream.ts"],"names":["makeDOMStream","source","options","iterator","Symbol","asyncIterator","ReadableStream","type","pull","controller","next","done","value","close","enqueue","Uint8Array","error","cancel","return","highWaterMark"],"mappings":";;;;;;;;;;;;;;;;;;;AAQO,SAASA,aAAT,CACLC,MADK,EAELC,OAFK,EAGW;AAChB,MAAMC,QAAQ,GAAGF,MAAM,CAACG,MAAM,CAACC,aAAR,CAAN,GACZJ,MAAD,CAAuCG,MAAM,CAACC,aAA9C,GADa,GAEZJ,MAAD,CAAkCG,MAAM,CAACD,QAAzC,GAFJ;AAIA,SAAO,IAAIG,cAAJ,CACL;AAKEC,IAAAA,IAAI,EAAE,OALR;AAOQC,IAAAA,IAPR,gBAOaC,UAPb,EAOyB;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAESN,QAAQ,CAACO,IAAT,EAFT;;AAAA;AAAA;AAEZC,gBAAAA,IAFY,wBAEZA,IAFY;AAENC,gBAAAA,KAFM,wBAENA,KAFM;;AAGnB,oBAAID,IAAJ,EAAU;AACRF,kBAAAA,UAAU,CAACI,KAAX;AACD,iBAFD,MAEO;AAELJ,kBAAAA,UAAU,CAACK,OAAX,CAAmB,IAAIC,UAAJ,CAAeH,KAAf,CAAnB;AACD;;AARkB;AAAA;;AAAA;AAAA;AAAA;AAUnBH,gBAAAA,UAAU,CAACO,KAAX;;AAVmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYtB,KAnBH;AAqBQC,IAAAA,MArBR,oBAqBiB;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBACPd,QADO,aACPA,QADO,2CACPA,QAAQ,CAAEe,MADH,qDACP,sBAAAf,QAAQ,CADD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEd;AAvBH,GADK;AA6BHgB,IAAAA,aAAa,WAAE,CAAF,EAAO,EAAP;AA7BV,KA8BAjB,OA9BA,EAAP;AAiCD","sourcesContent":["export type MakeDOMStreamOptions = {\n  /** Stream allocates an arrayBuffer. Enables use of a default reader. */\n  autoAllocateChunkSize?: number;\n  /** Total number of chunks in queue before back pressure is applied */\n  highWaterMark?: number;\n};\n\n/** Builds a DOM stream from an iterator */\nexport function makeDOMStream<ArrayBuffer>(\n  source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,\n  options?: MakeDOMStreamOptions\n): ReadableStream {\n  const iterator = source[Symbol.asyncIterator]\n    ? (source as AsyncIterable<ArrayBuffer>)[Symbol.asyncIterator]()\n    : (source as Iterable<ArrayBuffer>)[Symbol.iterator]();\n\n  return new ReadableStream<Uint8Array>(\n    {\n      // Create a byte stream (enables `Response(stream).arrayBuffer()`)\n      // Only supported on Chrome\n      // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController\n      // @ts-expect-error Only Chrome supports byte streams\n      type: 'bytes',\n\n      async pull(controller) {\n        try {\n          const {done, value} = await iterator.next();\n          if (done) {\n            controller.close();\n          } else {\n            // TODO - ignores controller.desiredSize\n            controller.enqueue(new Uint8Array(value));\n          }\n        } catch (error) {\n          controller.error(error);\n        }\n      },\n\n      async cancel() {\n        await iterator?.return?.();\n      }\n    },\n    // options: QueingStrategy<Uint8Array>\n    {\n      // This is bytes, not chunks\n      highWaterMark: 2 ** 24,\n      ...options\n    }\n  );\n}\n"],"file":"make-dom-stream.js"}