@bytescale/sdk 1.1.0 → 1.2.0

package/dist/node/esm/main.mjs

@@ -20,53 +20,10 @@
 // }
 // ----------------------------------------
 //
-import * as __WEBPACK_EXTERNAL_MODULE_buffer__ from "buffer";
 import * as __WEBPACK_EXTERNAL_MODULE_stream__ from "stream";
-/******/ var __lib_libs__ = ({
-
-/***/ "buffer":
-/***/ (function(lib) {
-
-var x = y => { var x = {}; __lib_require__.d(x, y); return x; }
-var y = x => () => x
-lib.exports = __WEBPACK_EXTERNAL_MODULE_buffer__;
-
-/***/ }),
-
-/***/ "stream":
-/***/ (function(lib) {
-
-var x = y => { var x = {}; __lib_require__.d(x, y); return x; }
-var y = x => () => x
-lib.exports = __WEBPACK_EXTERNAL_MODULE_stream__;
-
-/***/ })
-
-/******/ });
-/************************************************************************/
-/******/ // The lib cache
-/******/ var __lib_lib_cache__ = {};
-/******/ 
-/******/ // The require function
-/******/ function __lib_require__(libId) {
-/******/ 	// Check if lib is in cache
-/******/ 	var cachedModule = __lib_lib_cache__[libId];
-/******/ 	if (cachedModule !== undefined) {
-/******/ 		return cachedModule.exports;
-/******/ 	}
-/******/ 	// Create a new lib (and put it into the cache)
-/******/ 	var lib = __lib_lib_cache__[libId] = {
-/******/ 		// no lib.id needed
-/******/ 		// no lib.loaded needed
-/******/ 		exports: {}
-/******/ 	};
-/******/ 
-/******/ 	// Execute the lib function
-/******/ 	__lib_libs__[libId](lib, lib.exports, __lib_require__);
-/******/ 
-/******/ 	// Return the exports of the lib
-/******/ 	return lib.exports;
-/******/ }
+import * as __WEBPACK_EXTERNAL_MODULE_buffer__ from "buffer";
+/******/ // The require scope
+/******/ var __lib_require__ = {};
 /******/ 
 /************************************************************************/
 /******/ /* webpack/runtime/define property getters */
@@ -88,8 +45,6 @@ lib.exports = __WEBPACK_EXTERNAL_MODULE_stream__;
 /******/ 
 /************************************************************************/
 var __lib_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be isolated against other libs in the chunk.
-!function() {
 
 // EXPORTS
 __lib_require__.d(__lib_exports__, {
@@ -98,14 +53,10 @@ __lib_require__.d(__lib_exports__, {
   "BinaryResult": function() { return /* reexport */ BinaryResult; },
   "BytescaleApiError": function() { return /* reexport */ BytescaleApiError; },
   "CancelledError": function() { return /* reexport */ CancelledError; },
-  "ChunkedStream": function() { return /* reexport */ ChunkedStream; },
-  "FetchError": function() { return /* reexport */ FetchError; },
   "FileApi": function() { return /* reexport */ FileApi; },
   "FolderApi": function() { return /* reexport */ FolderApi; },
   "JSONApiResponse": function() { return /* reexport */ JSONApiResponse; },
   "JobApi": function() { return /* reexport */ JobApi; },
-  "RequiredError": function() { return /* reexport */ RequiredError; },
-  "ResponseError": function() { return /* reexport */ ResponseError; },
   "UploadApi": function() { return /* reexport */ UploadApi; },
   "UploadManager": function() { return /* reexport */ UploadManager; },
   "VoidApiResponse": function() { return /* reexport */ VoidApiResponse; },
@@ -205,11 +156,7 @@ var BaseAPI = /*#__PURE__*/function () {
         });
       }, function (e) {
         if (response === undefined) {
-          if (e instanceof Error) {
-            throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
-          } else {
-            throw e;
-          }
+          throw e;
         }
       }), function (_result) {
         return _exit ? _result : response;
@@ -244,7 +191,7 @@ var BaseAPI = /*#__PURE__*/function () {
               }
             }, function (_result2) {
               if (_exit2) return _result2;
-              throw new ResponseError(response, "Response returned an error code");
+              throw new Error("Unable to connect to the Bytescale API: please try again.");
             });
           });
         });
@@ -299,7 +246,7 @@ var BaseAPI = /*#__PURE__*/function () {
           }), function (_initOverrideFn) {
             var overriddenInit = Object.assign(_Object$assign2, _initOverrideFn);
             var init = Object.assign(Object.assign({}, overriddenInit), {
-              body: isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body) ? overriddenInit.body : JSON.stringify(overriddenInit.body)
+              body: JSON.stringify(overriddenInit.body)
             });
             return {
               url: url,
@@ -314,12 +261,6 @@ var BaseAPI = /*#__PURE__*/function () {
   }]);
   return BaseAPI;
 }();
-function isBlob(value) {
-  return typeof Blob !== "undefined" && value instanceof Blob;
-}
-function isFormData(value) {
-  return typeof FormData !== "undefined" && value instanceof FormData;
-}
 var BytescaleApiError = /*#__PURE__*/function (_Error) {
   _inherits(BytescaleApiError, _Error);
   var _super = _createSuper(BytescaleApiError);
@@ -334,45 +275,6 @@ var BytescaleApiError = /*#__PURE__*/function (_Error) {
   }
   return _createClass(BytescaleApiError);
 }( /*#__PURE__*/_wrapNativeSuper(Error));
-var ResponseError = /*#__PURE__*/function (_Error2) {
-  _inherits(ResponseError, _Error2);
-  var _super2 = _createSuper(ResponseError);
-  function ResponseError(response, msg) {
-    var _this7;
-    _classCallCheck(this, ResponseError);
-    _this7 = _super2.call(this, msg);
-    _this7.response = response;
-    _this7.name = "ResponseError";
-    return _this7;
-  }
-  return _createClass(ResponseError);
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-var FetchError = /*#__PURE__*/function (_Error3) {
-  _inherits(FetchError, _Error3);
-  var _super3 = _createSuper(FetchError);
-  function FetchError(cause, msg) {
-    var _this8;
-    _classCallCheck(this, FetchError);
-    _this8 = _super3.call(this, msg);
-    _this8.cause = cause;
-    _this8.name = "FetchError";
-    return _this8;
-  }
-  return _createClass(FetchError);
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-var RequiredError = /*#__PURE__*/function (_Error4) {
-  _inherits(RequiredError, _Error4);
-  var _super4 = _createSuper(RequiredError);
-  function RequiredError(field, msg) {
-    var _this9;
-    _classCallCheck(this, RequiredError);
-    _this9 = _super4.call(this, msg);
-    _this9.field = field;
-    _this9.name = "RequiredError";
-    return _this9;
-  }
-  return _createClass(RequiredError);
-}( /*#__PURE__*/_wrapNativeSuper(Error));
 function querystring(params) {
   var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
   return Object.keys(params).map(function (key) {
@@ -415,10 +317,10 @@ var JSONApiResponse = /*#__PURE__*/function () {
     key: "value",
     value: function value() {
       try {
-        var _this11 = this;
-        var _transformer2 = _this11.transformer;
-        return _await(_this11.raw.json(), function (_this10$raw$json) {
-          return _transformer2.call(_this11, _this10$raw$json);
+        var _this8 = this;
+        var _transformer2 = _this8.transformer;
+        return _await(_this8.raw.json(), function (_this7$raw$json) {
+          return _transformer2.call(_this8, _this7$raw$json);
         });
       } catch (e) {
         return Promise.reject(e);
@@ -460,8 +362,8 @@ var BinaryResult = /*#__PURE__*/function () {
     key: "text",
     value: function text() {
       try {
-        var _this13 = this;
-        return _await(_this13.raw.text());
+        var _this10 = this;
+        return _await(_this10.raw.text());
       } catch (e) {
         return Promise.reject(e);
       }
@@ -470,8 +372,8 @@ var BinaryResult = /*#__PURE__*/function () {
     key: "blob",
     value: function blob() {
       try {
-        var _this15 = this;
-        return _await(_this15.raw.blob());
+        var _this12 = this;
+        return _await(_this12.raw.blob());
       } catch (e) {
         return Promise.reject(e);
       }
@@ -480,8 +382,8 @@ var BinaryResult = /*#__PURE__*/function () {
     key: "json",
     value: function json() {
       try {
-        var _this17 = this;
-        return _await(_this17.raw.json());
+        var _this14 = this;
+        return _await(_this14.raw.json());
       } catch (e) {
         return Promise.reject(e);
       }
@@ -1380,312 +1282,40 @@ var UploadApi = /*#__PURE__*/function (_runtime$BaseAPI) {
 
 
 
-;// CONCATENATED MODULE: ./src/uploads/NodeUtils.ts
-function NodeUtils_typeof(obj) { "@babel/helpers - typeof"; return NodeUtils_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, NodeUtils_typeof(obj); }
-function NodeUtils_await(value, then, direct) {
-  if (direct) {
-    return then ? then(value) : value;
-  }
-  if (!value || !value.then) {
-    value = Promise.resolve(value);
-  }
-  return then ? value.then(then) : value;
-}
-function NodeUtils_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function NodeUtils_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, NodeUtils_toPropertyKey(descriptor.key), descriptor); } }
-function NodeUtils_createClass(Constructor, protoProps, staticProps) { if (protoProps) NodeUtils_defineProperties(Constructor.prototype, protoProps); if (staticProps) NodeUtils_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function NodeUtils_toPropertyKey(arg) { var key = NodeUtils_toPrimitive(arg, "string"); return NodeUtils_typeof(key) === "symbol" ? key : String(key); }
-function NodeUtils_toPrimitive(input, hint) { if (NodeUtils_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (NodeUtils_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-/**
- * Provides access to Node.js built-in libraries. Should only be called when we're certain we're running in Node.js.
- *
- * We import lazily to support browsers, which don't have these libs, but also won't call these methods so won't trigger the imports.
- */
-var NodeUtils = /*#__PURE__*/function () {
-  function NodeUtils() {
-    NodeUtils_classCallCheck(this, NodeUtils);
-  }
-  NodeUtils_createClass(NodeUtils, null, [{
-    key: "createStream",
-    value: function createStream() {
-      try {
-        return NodeUtils_await(Promise.resolve(/* import() */).then(__lib_require__.bind(__lib_require__, "stream")), function (_import) {
-          var streamModule = _import["default"];
-          var Readable = streamModule.Readable;
-          var readable = new Readable();
-          readable._read = function () {}; // _read is required but you can noop it
-          return readable;
-        });
-      } catch (e) {
-        return Promise.reject(e);
-      }
-    }
-  }, {
-    key: "createBlob",
-    value: function createBlob(sources, options) {
-      try {
-        return NodeUtils_await(Promise.resolve(/* import() */).then(__lib_require__.bind(__lib_require__, "buffer")), function (_import2) {
-          var bufferModule = _import2["default"];
-          var B = bufferModule.Blob;
-          return new B(sources, options);
-        });
-      } catch (e) {
-        return Promise.reject(e);
-      }
-    }
-  }]);
-  return NodeUtils;
-}();
-;// CONCATENATED MODULE: ./src/uploads/ChunkedStream.ts
-function ChunkedStream_typeof(obj) { "@babel/helpers - typeof"; return ChunkedStream_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, ChunkedStream_typeof(obj); }
-function ChunkedStream_invoke(body, then) {
-  var result = body();
-  if (result && result.then) {
-    return result.then(then);
-  }
-  return then(result);
-}
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-function ChunkedStream_await(value, then, direct) {
-  if (direct) {
-    return then ? then(value) : value;
-  }
-  if (!value || !value.then) {
-    value = Promise.resolve(value);
-  }
-  return then ? value.then(then) : value;
-}
-function ChunkedStream_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function ChunkedStream_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, ChunkedStream_toPropertyKey(descriptor.key), descriptor); } }
-function ChunkedStream_createClass(Constructor, protoProps, staticProps) { if (protoProps) ChunkedStream_defineProperties(Constructor.prototype, protoProps); if (staticProps) ChunkedStream_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function ChunkedStream_toPropertyKey(arg) { var key = ChunkedStream_toPrimitive(arg, "string"); return ChunkedStream_typeof(key) === "symbol" ? key : String(key); }
-function ChunkedStream_toPrimitive(input, hint) { if (ChunkedStream_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (ChunkedStream_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-
-var ChunkedStream = /*#__PURE__*/function () {
-  function ChunkedStream(source) {
-    ChunkedStream_classCallCheck(this, ChunkedStream);
-    this.source = source;
-    this.buffer = Buffer.alloc(0);
-    this.isSourceFullyConsumed = false; // true if the source stream indicates it has finished.
-    this.isFinishedConsuming = false; // true if _we_ indicate we have finished reading all we want from the stream.
-    this.resolver = undefined;
-  }
-  /**
-   * If the source stream is larger than the 'size' the user is consuming (i.e. they're only wanting to upload a subset
-   * of the stream) then the stream won't be resolved by the 'end' event inside 'runChunkPipeline', so calling this
-   * method is necessary.
-   */
-  ChunkedStream_createClass(ChunkedStream, [{
-    key: "finishedConsuming",
-    value: function finishedConsuming() {
-      this.isFinishedConsuming = true;
-      if (this.resolver !== undefined) {
-        this.resolver();
-      }
-    }
-    /**
-     * Promise resolves when the entire stream has finished processing, or an error occurs.
-     * You must call 'take' a sufficient number of times after calling this method in order for this promise to resolve.
-     */
-  }, {
-    key: "runChunkPipeline",
-    value: function runChunkPipeline() {
-      try {
-        var _this2 = this;
-        return ChunkedStream_await(new Promise(function (resolve, reject) {
-          _this2.resolver = resolve;
-          var onError = function onError(error) {
-            removeListeners();
-            reject(error);
-          };
-          var onEnd = function onEnd() {
-            _this2.isSourceFullyConsumed = true;
-            removeListeners();
-            resolve();
-          };
-          var onData = function onData(buffer) {
-            try {
-              if (_this2.isFinishedConsuming) {
-                return;
-              }
-              if (_this2.consumer === undefined) {
-                console.warn("Stream yielded data while paused. The data will be buffered, but excessive buffering can cause memory issues.");
-                _this2.buffer = Buffer.concat([_this2.buffer, buffer]);
-                return;
-              }
-              if (_this2.consumer.bytesRemaining <= 0) {
-                throw new Error("Consumer requires zero bytes, so should not be consuming from the stream.");
-              }
-              if (_this2.buffer.byteLength > 0) {
-                throw new Error("Buffer was expected to be empty (as it should have been flushed to the consumer when '.take' was called).");
-              }
-              var splitResult = _this2.splitBuffer(buffer, _this2.consumer.bytesRemaining);
-              if (splitResult === undefined) {
-                return; // Received empty data.
-              }
-
-              var _splitResult = _slicedToArray(splitResult, 2),
-                consumed = _splitResult[0],
-                remaining = _splitResult[1];
-              _this2.buffer = remaining;
-              _this2.consumer.bytesRemaining -= consumed.byteLength;
-              _this2.consumer.stream.push(consumed);
-              if (_this2.consumer.bytesRemaining === 0) {
-                _this2.finishStream(_this2.consumer.stream);
-                _this2.consumer = undefined;
-                _this2.source.pause();
-              }
-            } catch (e) {
-              removeListeners();
-              reject(e);
-            }
-          };
-          var removeListeners = function removeListeners() {
-            _this2.source.removeListener("data", onData);
-            _this2.source.removeListener("error", onError);
-            _this2.source.removeListener("end", onEnd);
-          };
-          _this2.source.on("data", onData);
-          _this2.source.on("error", onError);
-          _this2.source.on("end", onEnd);
-          _this2.source.pause(); // Resumed when 'take' is called.
-        }));
-      } catch (e) {
-        return Promise.reject(e);
-      }
-    }
-    /**
-     * Only call 'take' after the previously returned stream has been fully consumed.
-     */
-  }, {
-    key: "take",
-    value: function take(bytes) {
-      try {
-        var _exit2 = false;
-        var _this4 = this;
-        var _a;
-        if (_this4.consumer !== undefined) {
-          throw new Error("The stream from the previous 'take' call must be fully consumed before calling 'take' again.");
-        }
-        return ChunkedStream_invoke(function () {
-          if (bytes <= 0) {
-            _exit2 = true;
-            return ChunkedStream_await(_this4.emptyStream());
-          }
-        }, function (_result) {
-          return _exit2 ? _result : ChunkedStream_await(NodeUtils.createStream(), function (readable) {
-            var consumedFromBuffer = _this4.consumeFromBuffer(bytes);
-            var consumedFromBufferLength = (_a = consumedFromBuffer === null || consumedFromBuffer === void 0 ? void 0 : consumedFromBuffer.length) !== null && _a !== void 0 ? _a : 0;
-            var bytesToConsumeFromStream = bytes - consumedFromBufferLength;
-            if (consumedFromBuffer !== undefined) {
-              readable.push(consumedFromBuffer);
-            }
-            if (bytesToConsumeFromStream > 0) {
-              if (_this4.isSourceFullyConsumed) {
-                throw new Error("Stream finished processing earlier than expected. The \"size\" parameter is likely larger than the stream's actual contents.");
-              }
-              _this4.consumer = {
-                bytesRemaining: bytesToConsumeFromStream,
-                stream: readable
-              };
-              _this4.source.resume();
-            } else {
-              _this4.finishStream(readable);
-            }
-            return readable;
-          });
-        });
-      } catch (e) {
-        return Promise.reject(e);
-      }
-    }
-  }, {
-    key: "consumeFromBuffer",
-    value: function consumeFromBuffer(bytes) {
-      var splitResult = this.splitBuffer(this.buffer, bytes);
-      if (splitResult === undefined) {
-        return undefined;
-      }
-      var _splitResult2 = _slicedToArray(splitResult, 2),
-        consumed = _splitResult2[0],
-        remaining = _splitResult2[1];
-      this.buffer = remaining;
-      return consumed;
-    }
-  }, {
-    key: "splitBuffer",
-    value: function splitBuffer(buffer, maxBytes) {
-      if (buffer.byteLength === 0) {
-        return undefined;
-      }
-      var bytesToConsume = Math.min(maxBytes, buffer.byteLength);
-      if (bytesToConsume === buffer.byteLength) {
-        return [buffer, Buffer.alloc(0)]; // Optimization
-      }
-
-      var consumed = buffer.subarray(0, bytesToConsume);
-      var remaining = buffer.subarray(bytesToConsume);
-      return [consumed, remaining];
-    }
-  }, {
-    key: "emptyStream",
-    value: function emptyStream() {
-      try {
-        var _this6 = this;
-        return ChunkedStream_await(NodeUtils.createStream(), function (readable) {
-          _this6.finishStream(readable);
-          return readable;
-        });
-      } catch (e) {
-        return Promise.reject(e);
-      }
-    }
-  }, {
-    key: "finishStream",
-    value: function finishStream(readable) {
-      readable.push(null);
-    }
-  }]);
-  return ChunkedStream;
-}();
-;// CONCATENATED MODULE: ./src/uploads/UploadModel.ts
-function UploadModel_typeof(obj) { "@babel/helpers - typeof"; return UploadModel_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadModel_typeof(obj); }
-function UploadModel_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadModel_toPropertyKey(descriptor.key), descriptor); } }
-function UploadModel_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadModel_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadModel_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function UploadModel_toPropertyKey(arg) { var key = UploadModel_toPrimitive(arg, "string"); return UploadModel_typeof(key) === "symbol" ? key : String(key); }
-function UploadModel_toPrimitive(input, hint) { if (UploadModel_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadModel_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function UploadModel_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function UploadModel_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) UploadModel_setPrototypeOf(subClass, superClass); }
-function UploadModel_createSuper(Derived) { var hasNativeReflectConstruct = UploadModel_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = UploadModel_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = UploadModel_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return UploadModel_possibleConstructorReturn(this, result); }; }
-function UploadModel_possibleConstructorReturn(self, call) { if (call && (UploadModel_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return UploadModel_assertThisInitialized(self); }
-function UploadModel_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function UploadModel_wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; UploadModel_wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !UploadModel_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return UploadModel_construct(Class, arguments, UploadModel_getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return UploadModel_setPrototypeOf(Wrapper, Class); }; return UploadModel_wrapNativeSuper(Class); }
-function UploadModel_construct(Parent, args, Class) { if (UploadModel_isNativeReflectConstruct()) { UploadModel_construct = Reflect.construct.bind(); } else { UploadModel_construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) UploadModel_setPrototypeOf(instance, Class.prototype); return instance; }; } return UploadModel_construct.apply(null, arguments); }
-function UploadModel_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function UploadModel_isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
-function UploadModel_setPrototypeOf(o, p) { UploadModel_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return UploadModel_setPrototypeOf(o, p); }
-function UploadModel_getPrototypeOf(o) { UploadModel_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return UploadModel_getPrototypeOf(o); }
+;// CONCATENATED MODULE: ./src/uploads/public/shared/Model.ts
+function Model_typeof(obj) { "@babel/helpers - typeof"; return Model_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, Model_typeof(obj); }
+function Model_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, Model_toPropertyKey(descriptor.key), descriptor); } }
+function Model_createClass(Constructor, protoProps, staticProps) { if (protoProps) Model_defineProperties(Constructor.prototype, protoProps); if (staticProps) Model_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function Model_toPropertyKey(arg) { var key = Model_toPrimitive(arg, "string"); return Model_typeof(key) === "symbol" ? key : String(key); }
+function Model_toPrimitive(input, hint) { if (Model_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (Model_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function Model_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function Model_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) Model_setPrototypeOf(subClass, superClass); }
+function Model_createSuper(Derived) { var hasNativeReflectConstruct = Model_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = Model_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = Model_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Model_possibleConstructorReturn(this, result); }; }
+function Model_possibleConstructorReturn(self, call) { if (call && (Model_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return Model_assertThisInitialized(self); }
+function Model_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function Model_wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; Model_wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !Model_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return Model_construct(Class, arguments, Model_getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return Model_setPrototypeOf(Wrapper, Class); }; return Model_wrapNativeSuper(Class); }
+function Model_construct(Parent, args, Class) { if (Model_isNativeReflectConstruct()) { Model_construct = Reflect.construct.bind(); } else { Model_construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) Model_setPrototypeOf(instance, Class.prototype); return instance; }; } return Model_construct.apply(null, arguments); }
+function Model_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function Model_isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+function Model_setPrototypeOf(o, p) { Model_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return Model_setPrototypeOf(o, p); }
+function Model_getPrototypeOf(o) { Model_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return Model_getPrototypeOf(o); }
 var CancelledError = /*#__PURE__*/function (_Error) {
-  UploadModel_inherits(CancelledError, _Error);
-  var _super = UploadModel_createSuper(CancelledError);
-  function CancelledError(msg) {
+  Model_inherits(CancelledError, _Error);
+  var _super = Model_createSuper(CancelledError);
+  function CancelledError() {
     var _this;
-    UploadModel_classCallCheck(this, CancelledError);
-    _this = _super.call(this, msg);
-    _this.msg = msg;
+    Model_classCallCheck(this, CancelledError);
+    _this = _super.call(this, "Upload cancelled by user.");
     _this.name = "CancelledError";
     return _this;
   }
-  return UploadModel_createClass(CancelledError);
-}( /*#__PURE__*/UploadModel_wrapNativeSuper(Error));
-;// CONCATENATED MODULE: ./src/uploads/UploadManager.ts
-function UploadManager_typeof(obj) { "@babel/helpers - typeof"; return UploadManager_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadManager_typeof(obj); }
-function UploadManager_async(f) {
+  return Model_createClass(CancelledError);
+}( /*#__PURE__*/Model_wrapNativeSuper(Error));
+;// CONCATENATED MODULE: ./src/uploads/public/shared/index.ts
+
+;// CONCATENATED MODULE: ./src/uploads/private/UploadManagerBase.ts
+function UploadManagerBase_typeof(obj) { "@babel/helpers - typeof"; return UploadManagerBase_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadManagerBase_typeof(obj); }
+function UploadManagerBase_async(f) {
   return function () {
     for (var args = [], i = 0; i < arguments.length; i++) {
       args[i] = arguments[i];
@@ -1697,23 +1327,10 @@ function UploadManager_async(f) {
     }
   };
 }
-function UploadManager_empty() {}
-function _awaitIgnored(value, direct) {
-  if (!direct) {
-    return value && value.then ? value.then(UploadManager_empty) : Promise.resolve();
-  }
-}
-function UploadManager_invoke(body, then) {
-  var result = body();
-  if (result && result.then) {
-    return result.then(then);
-  }
-  return then(result);
-}
 function _invokeIgnored(body) {
   var result = body();
   if (result && result.then) {
-    return result.then(UploadManager_empty);
+    return result.then(UploadManagerBase_empty);
   }
 }
 function _settle(pact, state, value) {
@@ -1867,16 +1484,22 @@ function _for(test, update, body) {
 }
 function _continueIgnored(value) {
   if (value && value.then) {
-    return value.then(UploadManager_empty);
+    return value.then(UploadManagerBase_empty);
   }
 }
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || UploadManager_unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function UploadManager_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return UploadManager_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return UploadManager_arrayLikeToArray(o, minLen); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return UploadManager_arrayLikeToArray(arr); }
-function UploadManager_arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-function UploadManager_await(value, then, direct) {
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function UploadManagerBase_empty() {}
+function _awaitIgnored(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(UploadManagerBase_empty) : Promise.resolve();
+  }
+}
+function UploadManagerBase_await(value, then, direct) {
   if (direct) {
     return then ? then(value) : value;
   }
@@ -1885,46 +1508,73 @@ function UploadManager_await(value, then, direct) {
   }
   return then ? value.then(then) : value;
 }
-function UploadManager_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function UploadManager_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadManager_toPropertyKey(descriptor.key), descriptor); } }
-function UploadManager_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadManager_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadManager_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function UploadManager_toPropertyKey(arg) { var key = UploadManager_toPrimitive(arg, "string"); return UploadManager_typeof(key) === "symbol" ? key : String(key); }
-function UploadManager_toPrimitive(input, hint) { if (UploadManager_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadManager_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-
-
+function _rethrow(thrown, value) {
+  if (thrown) throw value;
+  return value;
+}
+function _finallyRethrows(body, finalizer) {
+  try {
+    var result = body();
+  } catch (e) {
+    return finalizer(true, e);
+  }
+  if (result && result.then) {
+    return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
+  }
+  return finalizer(false, result);
+}
+function UploadManagerBase_continue(value, then) {
+  return value && value.then ? value.then(then) : then(value);
+}
+function UploadManagerBase_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UploadManagerBase_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadManagerBase_toPropertyKey(descriptor.key), descriptor); } }
+function UploadManagerBase_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadManagerBase_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadManagerBase_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UploadManagerBase_toPropertyKey(arg) { var key = UploadManagerBase_toPrimitive(arg, "string"); return UploadManagerBase_typeof(key) === "symbol" ? key : String(key); }
+function UploadManagerBase_toPrimitive(input, hint) { if (UploadManagerBase_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadManagerBase_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 
 
-var UploadManager = /*#__PURE__*/function () {
-  function UploadManager(config) {
-    UploadManager_classCallCheck(this, UploadManager);
+/**
+ * Methods common to UploadManagerNode and UploadManagerBrowser.
+ */
+var UploadManagerBase = /*#__PURE__*/function () {
+  function UploadManagerBase(config) {
+    UploadManagerBase_classCallCheck(this, UploadManagerBase);
     this.config = config;
     this.stringMimeType = "text/plain";
     this.defaultMaxConcurrentUploadParts = 4;
+    this.intervalMs = 500;
     this.uploadApi = new UploadApi(config);
   }
-  UploadManager_createClass(UploadManager, [{
+  UploadManagerBase_createClass(UploadManagerBase, [{
     key: "upload",
     value: function upload(request) {
       try {
         var _this2 = this;
-        return UploadManager_await(_this2.processUploadSource(request.data), function (data) {
-          var chunkedStream = _this2.getChunkedStream(data);
-          return UploadManager_await(_this2.beginUpload(request, data), function (uploadInfo) {
-            _this2.checkIfCancelled(request);
-            var maxConcurrency = _this2.calculateMaxConcurrency(request, data);
-            var partCount = uploadInfo.uploadParts.count;
-            var parts = _toConsumableArray(Array(partCount).keys());
-            var runSourceStreamPump = chunkedStream === null || chunkedStream === void 0 ? void 0 : chunkedStream.runChunkPipeline();
-            return UploadManager_await(_this2.mapAsync(parts, maxConcurrency, UploadManager_async(function (part) {
-              return _this2.uploadPart(request, data, part, uploadInfo);
+        _this2.assertNotCancelled(request);
+        var source = _this2.processUploadSource(request.data);
+        var preUploadInfo = _this2.getPreUploadInfo(request, source);
+        var onProgress = _this2.makeProgressCallback(request, preUploadInfo.size);
+        var init = _this2.preUpload(source);
+        // Raise initial progress event SYNCHRONOUSLY.
+        onProgress(0);
+        return UploadManagerBase_await(_this2.beginUpload(request, preUploadInfo), function (uploadInfo) {
+          var partCount = uploadInfo.uploadParts.count;
+          var parts = _toConsumableArray(Array(partCount).keys());
+          var _this2$makeCancellati = _this2.makeCancellationMethods(),
+            cancel = _this2$makeCancellati.cancel,
+            addCancellationHandler = _this2$makeCancellati.addCancellationHandler;
+          var intervalHandle = setInterval(_this2.onIntervalTick(request, cancel), _this2.intervalMs);
+          return UploadManagerBase_continue(_finallyRethrows(function () {
+            return UploadManagerBase_await(_this2.mapAsync(parts, preUploadInfo.maxConcurrentUploadParts, UploadManagerBase_async(function (part) {
+              return _this2.uploadPart(request, source, part, uploadInfo, onProgress, addCancellationHandler);
             })), function () {
-              if (chunkedStream !== undefined) {
-                chunkedStream.finishedConsuming();
-              }
-              return UploadManager_await(runSourceStreamPump, function () {
-                return uploadInfo.file;
-              });
+              return _awaitIgnored(_this2.postUpload(init));
             });
+          }, function (_wasThrown, _result) {
+            clearInterval(intervalHandle);
+            return _rethrow(_wasThrown, _result);
+          }), function () {
+            return uploadInfo.file;
           });
         });
       } catch (e) {
@@ -1932,22 +1582,85 @@ var UploadManager = /*#__PURE__*/function () {
       }
     }
   }, {
-    key: "checkIfCancelled",
-    value: function checkIfCancelled(request) {
-      var _a;
-      if (((_a = request.cancellationToken) === null || _a === void 0 ? void 0 : _a.isCancelled) === true) {
-        throw new CancelledError("Upload cancelled by user.");
+    key: "getBlobInfo",
+    value: function getBlobInfo(_ref) {
+      var _ref$value = _ref.value,
+        name = _ref$value.name,
+        size = _ref$value.size,
+        type = _ref$value.type;
+      return {
+        mime: type,
+        size: size,
+        originalFileName: name,
+        maxConcurrentUploadParts: undefined
+      };
+    }
+  }, {
+    key: "onIntervalTick",
+    value: function onIntervalTick(request, cancel) {
+      var _this3 = this;
+      return function () {
+        if (_this3.isCancelled(request)) {
+          cancel();
+        }
+      };
+    }
+  }, {
+    key: "makeCancellationMethods",
+    value: function makeCancellationMethods() {
+      var cancellationHandlers = [];
+      var addCancellationHandler = function addCancellationHandler(ca) {
+        cancellationHandlers.push(ca);
+      };
+      var cancel = function cancel() {
+        return cancellationHandlers.forEach(function (x) {
+          return x();
+        });
+      };
+      return {
+        cancel: cancel,
+        addCancellationHandler: addCancellationHandler
+      };
+    }
+  }, {
+    key: "makeProgressCallback",
+    value: function makeProgressCallback(request, bytesTotal) {
+      var onProgress = request.onProgress;
+      if (onProgress === undefined) {
+        return function () {};
+      }
+      var bytesSent = 0;
+      return function (bytesSentDelta) {
+        bytesSent += bytesSentDelta;
+        onProgress({
+          bytesTotal: bytesTotal,
+          bytesSent: bytesSent,
+          progress: Math.round(bytesSent / bytesTotal * 100)
+        });
+      };
+    }
+  }, {
+    key: "assertNotCancelled",
+    value: function assertNotCancelled(request) {
+      if (this.isCancelled(request)) {
+        throw new CancelledError();
       }
     }
+  }, {
+    key: "isCancelled",
+    value: function isCancelled(request) {
+      var _a;
+      return ((_a = request.cancellationToken) === null || _a === void 0 ? void 0 : _a.isCancelled) === true;
+    }
   }, {
     key: "beginUpload",
-    value: function beginUpload(request, data) {
+    value: function beginUpload(request, _ref2) {
+      var size = _ref2.size,
+        mime = _ref2.mime,
+        originalFileName = _ref2.originalFileName;
       try {
-        var _this4 = this;
-        var size = _this4.calculateSize(request, data);
-        var mime = _this4.calculateMime(request, data);
-        var originalFileName = _this4.calculateOriginalFileName(request, data);
-        return UploadManager_await(_this4.uploadApi.beginMultipartUpload({
+        var _this5 = this;
+        return UploadManagerBase_await(_this5.uploadApi.beginMultipartUpload({
           accountId: request.accountId,
           beginMultipartUploadRequest: {
             metadata: request.metadata,
@@ -1965,15 +1678,15 @@ var UploadManager = /*#__PURE__*/function () {
     }
   }, {
     key: "uploadPart",
-    value: function uploadPart(request, data, partIndex, uploadInfo) {
+    value: function uploadPart(request, source, partIndex, uploadInfo, onProgress, addCancellationHandler) {
       try {
-        var _this6 = this;
-        _this6.checkIfCancelled(request);
-        return UploadManager_await(_this6.getUploadPart(request, partIndex, uploadInfo), function (part) {
-          _this6.checkIfCancelled(request);
-          return UploadManager_await(_this6.putUploadPart(part, data), function (etag) {
-            _this6.checkIfCancelled(request);
-            return _awaitIgnored(_this6.uploadApi.completeUploadPart({
+        var _this7 = this;
+        _this7.assertNotCancelled(request);
+        return UploadManagerBase_await(_this7.getUploadPart(request, partIndex, uploadInfo), function (part) {
+          _this7.assertNotCancelled(request);
+          return UploadManagerBase_await(_this7.putUploadPart(part, source, onProgress, addCancellationHandler), function (etag) {
+            _this7.assertNotCancelled(request);
+            return _awaitIgnored(_this7.uploadApi.completeUploadPart({
               accountId: request.accountId,
               uploadId: uploadInfo.uploadId,
               uploadPartIndex: partIndex,
@@ -1992,422 +1705,720 @@ var UploadManager = /*#__PURE__*/function () {
      */
   }, {
     key: "putUploadPart",
-    value: function putUploadPart(part, data) {
+    value: function putUploadPart(part, source, onProgress, addCancellationHandler) {
       try {
-        var _this8 = this;
-        var _a, _b;
-        var fetchApi = (_a = _this8.config.fetchApi) !== null && _a !== void 0 ? _a : fetch;
-        var headers = {
-          // Required to prevent fetch using "Transfer-Encoding: Chunked" when body is a stream.
-          "content-length": (part.range.inclusiveEnd + 1 - part.range.inclusiveStart).toString()
-        };
-        var _part$uploadUrl2 = part.uploadUrl,
-          _coerceRequestBody2 = _this8.coerceRequestBody;
-        return UploadManager_await(_this8.makeRequestBody(part, data), function (_this7$makeRequestBod) {
-          return UploadManager_await(fetchApi(_part$uploadUrl2, {
-            method: "PUT",
-            headers: headers,
-            body: _coerceRequestBody2.call(_this8, _this7$makeRequestBod)
-          }), function (response) {
-            var _exit = false;
-            var etag = (_b = response.headers.get("etag")) !== null && _b !== void 0 ? _b : undefined;
-            return UploadManager_invoke(function () {
-              if (Math.floor(response.status / 100) !== 2) {
-                return UploadManager_await(response.text(), function (_response$text) {
-                  console.error("Failed to upload part (".concat(response.status, "). Response from server:\n").concat(_response$text));
-                  throw new Error("Failed to upload part (".concat(response.status, ")."));
-                });
-              }
-            }, function (_result) {
-              if (_exit) return _result;
-              if (etag === undefined) {
-                throw new Error("No 'etag' response header found in upload part response.");
-              }
-              return etag;
-            });
-          });
+        var _this9 = this;
+        var contentLength = part.range.inclusiveEnd + 1 - part.range.inclusiveStart;
+        return UploadManagerBase_await(_this9.doPutUploadPart(part, contentLength, source, onProgress, addCancellationHandler), function (_ref3) {
+          var status = _ref3.status,
+            etag = _ref3.etag;
+          if (Math.floor(status / 100) !== 2) {
+            throw new Error("Failed to upload part (".concat(status, ")."));
+          }
+          if (etag === undefined) {
+            throw new Error("No 'etag' response header found in upload part response.");
+          }
+          return etag;
         });
       } catch (e) {
         return Promise.reject(e);
       }
     }
   }, {
-    key: "coerceRequestBody",
-    value: function coerceRequestBody(data) {
-      return data; // node-fetch supports 'NodeJS.ReadableStream'
-    }
-  }, {
-    key: "makeRequestBody",
-    value: function makeRequestBody(part, data) {
+    key: "getUploadPart",
+    value: function getUploadPart(request, partIndex, uploadInfo) {
       try {
-        var _this10 = this;
-        return UploadManager_await(_this10.sliceDataForRequest(data, part), function (slicedData) {
-          var isNodeJs = _this10.isNodeJs();
-          // node-fetch requires 'NodeJS.ReadableStream' for the body.
-          // browser fetch supports blobs and buffers.
-          return UploadManager_await(_this10.foldDataRaw(slicedData, {
-            ifBuffer: UploadManager_async(function (buffer) {
-              return isNodeJs ? _this10.bufferToStream(buffer) : buffer;
-            }),
-            ifBlob: UploadManager_async(function (blob) {
-              var _bufferToStream = isNodeJs && _this10.bufferToStream;
-              return UploadManager_await(isNodeJs ? _this10.blobToBuffer(blob) : blob, function (_this10$blobToBuffer) {
-                return UploadManager_await(isNodeJs ? _bufferToStream.call(_this10, _this10$blobToBuffer) : _this10$blobToBuffer, void 0, !isNodeJs);
-              }, !isNodeJs);
-            }),
-            ifNodeJsStream: function (stream) {
-              return UploadManager_await(stream);
-            }
-          }));
-        });
+        var _this11 = this;
+        if (partIndex === 0) {
+          return uploadInfo.uploadParts.first;
+        }
+        return UploadManagerBase_await(_this11.uploadApi.getUploadPart({
+          uploadId: uploadInfo.uploadId,
+          accountId: request.accountId,
+          uploadPartIndex: partIndex
+        }));
       } catch (e) {
         return Promise.reject(e);
       }
     }
   }, {
-    key: "bufferToStream",
-    value: function bufferToStream(buffer) {
+    key: "getPreUploadInfo",
+    value: function getPreUploadInfo(request, source) {
+      var _a, _b, _c;
+      var partial = this.getPreUploadInfoPartial(request, source);
+      return {
+        maxConcurrentUploadParts: (_a = partial.maxConcurrentUploadParts) !== null && _a !== void 0 ? _a : this.defaultMaxConcurrentUploadParts,
+        originalFileName: (_b = request.originalFileName) !== null && _b !== void 0 ? _b : partial.originalFileName,
+        mime: (_c = request.mime) !== null && _c !== void 0 ? _c : partial.mime,
+        size: partial.size
+      };
+    }
+  }, {
+    key: "mapAsync",
+    value: function mapAsync(items, concurrency, callback) {
       try {
-        return UploadManager_await(NodeUtils.createStream(), function (readable) {
-          readable.push(buffer);
-          readable.push(null);
-          return readable;
-        });
+        var workQueue = _toConsumableArray(items);
+        return _awaitIgnored(Promise.all(_toConsumableArray(Array(concurrency).keys()).map(UploadManagerBase_async(function () {
+          return _continueIgnored(_for(function () {
+            return workQueue.length > 0;
+          }, void 0, function () {
+            var work = workQueue.shift(); // IMPORTANT: use 'shift' instead of 'pop' to ensure 'items' are processed in order when 'concurrency = 1'.
+            return _invokeIgnored(function () {
+              if (work !== undefined) {
+                return _awaitIgnored(callback(work));
+              }
+            });
+          }));
+        }))));
       } catch (e) {
         return Promise.reject(e);
       }
     }
+  }]);
+  return UploadManagerBase;
+}();
+;// CONCATENATED MODULE: external "stream"
+var x = y => { var x = {}; __lib_require__.d(x, y); return x; }
+var y = x => () => x
+var external_stream_namespaceObject = x({ ["Readable"]: () => __WEBPACK_EXTERNAL_MODULE_stream__.Readable });
+;// CONCATENATED MODULE: ./src/uploads/private/StreamUtils.ts
+function StreamUtils_typeof(obj) { "@babel/helpers - typeof"; return StreamUtils_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, StreamUtils_typeof(obj); }
+function StreamUtils_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function StreamUtils_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, StreamUtils_toPropertyKey(descriptor.key), descriptor); } }
+function StreamUtils_createClass(Constructor, protoProps, staticProps) { if (protoProps) StreamUtils_defineProperties(Constructor.prototype, protoProps); if (staticProps) StreamUtils_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function StreamUtils_toPropertyKey(arg) { var key = StreamUtils_toPrimitive(arg, "string"); return StreamUtils_typeof(key) === "symbol" ? key : String(key); }
+function StreamUtils_toPrimitive(input, hint) { if (StreamUtils_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (StreamUtils_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+var StreamUtils = /*#__PURE__*/function () {
+  function StreamUtils() {
+    StreamUtils_classCallCheck(this, StreamUtils);
+  }
+  StreamUtils_createClass(StreamUtils, null, [{
+    key: "create",
+    value: function create() {
+      var readable = new external_stream_namespaceObject.Readable();
+      readable._read = function () {}; // _read is required but you can noop it
+      return readable;
+    }
+  }, {
+    key: "empty",
+    value: function empty() {
+      var readable = StreamUtils.create();
+      StreamUtils.endStream(readable);
+      return readable;
+    }
+  }, {
+    key: "fromBuffer",
+    value: function fromBuffer(buffer) {
+      var readable = StreamUtils.create();
+      readable.push(buffer);
+      StreamUtils.endStream(readable);
+      return readable;
+    }
+  }, {
+    key: "endStream",
+    value: function endStream(readable) {
+      readable.push(null);
+    }
+  }]);
+  return StreamUtils;
+}();
+;// CONCATENATED MODULE: ./src/uploads/private/NodeChunkedStream.ts
+function NodeChunkedStream_typeof(obj) { "@babel/helpers - typeof"; return NodeChunkedStream_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, NodeChunkedStream_typeof(obj); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || NodeChunkedStream_unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function NodeChunkedStream_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return NodeChunkedStream_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return NodeChunkedStream_arrayLikeToArray(o, minLen); }
+function NodeChunkedStream_arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function NodeChunkedStream_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function NodeChunkedStream_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function NodeChunkedStream_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, NodeChunkedStream_toPropertyKey(descriptor.key), descriptor); } }
+function NodeChunkedStream_createClass(Constructor, protoProps, staticProps) { if (protoProps) NodeChunkedStream_defineProperties(Constructor.prototype, protoProps); if (staticProps) NodeChunkedStream_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function NodeChunkedStream_toPropertyKey(arg) { var key = NodeChunkedStream_toPrimitive(arg, "string"); return NodeChunkedStream_typeof(key) === "symbol" ? key : String(key); }
+function NodeChunkedStream_toPrimitive(input, hint) { if (NodeChunkedStream_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (NodeChunkedStream_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+/**
+ * For Node.js streams only:
+ *
+ * Converts a stream into a stream of streams, where the next stream is requested via '.take(sizeInBytes: number): Stream'
+ *
+ * This allows the source stream to be sequentially read (in serial) as a sequence of sub-streams, for the purpose of
+ * issuing PutObject requests for a multipart upload, whereby each request requires its own stream, but where that stream
+ * needs to be a slice of the source stream.
+ */
+var NodeChunkedStream = /*#__PURE__*/function () {
+  function NodeChunkedStream(source) {
+    NodeChunkedStream_classCallCheck(this, NodeChunkedStream);
+    this.source = source;
+    this.buffer = Buffer.alloc(0);
+    this.isSourceFullyConsumed = false; // true if the source stream indicates it has finished.
+    this.isFinishedConsuming = false; // true if _we_ indicate we have finished reading all we want from the stream.
+    this.resolver = undefined;
+  }
+  /**
+   * If the source stream is larger than the 'size' the user is consuming (i.e. they're only wanting to upload a subset
+   * of the stream) then the stream won't be resolved by the 'end' event inside 'runChunkPipeline', so calling this
+   * method is necessary.
+   */
+  NodeChunkedStream_createClass(NodeChunkedStream, [{
+    key: "finishedConsuming",
+    value: function finishedConsuming() {
+      this.isFinishedConsuming = true;
+      if (this.resolver !== undefined) {
+        this.resolver();
+      }
+    }
     /**
-     * Only expected to be called in Node.js environments, and as such, we can assume 'BlobLike' is not a DOM 'File' object.
+     * Promise resolves when the entire stream has finished processing, or an error occurs.
+     * You must call 'take' a sufficient number of times after calling this method in order for this promise to resolve.
      */
   }, {
-    key: "blobToBuffer",
-    value: function blobToBuffer(blob) {
+    key: "runChunkPipeline",
+    value: function runChunkPipeline() {
       try {
-        var _exit3 = false;
-        // DOM Blob and Node.js Blob both have 'arrayBuffer' with the same signature...
-        return UploadManager_invoke(function () {
-          if (blob.arrayBuffer !== undefined) {
-            _exit3 = true;
-            var _Buffer2 = Buffer,
-              _from2 = _Buffer2.from;
-            return UploadManager_await(blob.arrayBuffer(), function (_blob$arrayBuffer) {
-              return _from2.call(_Buffer2, _blob$arrayBuffer);
-            });
-          }
-        }, function (_result2) {
-          if (_exit3) return _result2;
-          throw new Error("The provided 'data' field was treated as a BLOB, but it does not have an 'arrayBuffer' method.");
-        });
+        var _this2 = this;
+        return NodeChunkedStream_await(new Promise(function (resolve, reject) {
+          _this2.resolver = resolve;
+          var onError = function onError(error) {
+            removeListeners();
+            reject(error);
+          };
+          var onEnd = function onEnd() {
+            _this2.isSourceFullyConsumed = true;
+            removeListeners();
+            resolve();
+          };
+          var onData = function onData(buffer) {
+            try {
+              if (_this2.isFinishedConsuming) {
+                return;
+              }
+              if (_this2.consumer === undefined) {
+                console.warn("Stream yielded data while paused. The data will be buffered, but excessive buffering can cause memory issues.");
+                _this2.buffer = Buffer.concat([_this2.buffer, buffer]);
+                return;
+              }
+              if (_this2.consumer.bytesRemaining <= 0) {
+                throw new Error("Consumer requires zero bytes, so should not be consuming from the stream.");
+              }
+              if (_this2.buffer.byteLength > 0) {
+                throw new Error("Buffer was expected to be empty (as it should have been flushed to the consumer when '.take' was called).");
+              }
+              var splitResult = _this2.splitBuffer(buffer, _this2.consumer.bytesRemaining);
+              if (splitResult === undefined) {
+                return; // Received empty data.
+              }
+
+              var _splitResult = _slicedToArray(splitResult, 2),
+                consumed = _splitResult[0],
+                remaining = _splitResult[1];
+              _this2.buffer = remaining;
+              _this2.consumer.bytesRemaining -= consumed.byteLength;
+              _this2.consumer.stream.push(consumed);
+              if (_this2.consumer.bytesRemaining === 0) {
+                StreamUtils.endStream(_this2.consumer.stream);
+                _this2.consumer = undefined;
+                _this2.source.pause();
+              }
+            } catch (e) {
+              removeListeners();
+              reject(e);
+            }
+          };
+          var removeListeners = function removeListeners() {
+            _this2.source.removeListener("data", onData);
+            _this2.source.removeListener("error", onError);
+            _this2.source.removeListener("end", onEnd);
+          };
+          _this2.source.on("data", onData);
+          _this2.source.on("error", onError);
+          _this2.source.on("end", onEnd);
+          _this2.source.pause(); // Resumed when 'take' is called.
+        }));
       } catch (e) {
         return Promise.reject(e);
       }
     }
+    /**
+     * Only call 'take' after the previously returned stream has been fully consumed.
+     */
   }, {
-    key: "sliceDataForRequest",
-    value: function sliceDataForRequest(data, part) {
-      try {
-        var _this12 = this;
-        if (part.range.inclusiveEnd === -1) {
-          return "";
+    key: "take",
+    value: function take(bytes) {
+      var _a;
+      if (this.consumer !== undefined) {
+        throw new Error("The stream from the previous 'take' call must be fully consumed before calling 'take' again.");
+      }
+      if (bytes <= 0) {
+        return StreamUtils.empty();
+      }
+      var readable = StreamUtils.create();
+      var consumedFromBuffer = this.consumeFromBuffer(bytes);
+      var consumedFromBufferLength = (_a = consumedFromBuffer === null || consumedFromBuffer === void 0 ? void 0 : consumedFromBuffer.length) !== null && _a !== void 0 ? _a : 0;
+      var bytesToConsumeFromStream = bytes - consumedFromBufferLength;
+      if (consumedFromBuffer !== undefined) {
+        readable.push(consumedFromBuffer);
+      }
+      if (bytesToConsumeFromStream > 0) {
+        if (this.isSourceFullyConsumed) {
+          throw new Error("Stream finished processing earlier than expected. The \"size\" parameter is likely larger than the stream's actual contents.");
         }
-        var start = part.range.inclusiveStart;
-        var endExclusive = part.range.inclusiveEnd + 1;
-        var partSize = endExclusive - start;
-        return UploadManager_await(_this12.foldData(data, {
-          ifBlob: UploadManager_async(function (blob) {
-            return blob.slice(start, endExclusive);
-          }),
-          ifBuffer: UploadManager_async(function (buffer) {
-            return buffer.subarray(start, endExclusive);
-          }),
-          ifNodeJsStream: UploadManager_async(function (stream) {
-            return stream.take(partSize);
-          }) // Assumes stream is read using one worker (which it is).
-        }));
-      } catch (e) {
-        return Promise.reject(e);
+        this.consumer = {
+          bytesRemaining: bytesToConsumeFromStream,
+          stream: readable
+        };
+        this.source.resume();
+      } else {
+        StreamUtils.endStream(readable);
       }
+      return readable;
     }
   }, {
-    key: "isNodeJs",
-    value: function isNodeJs() {
-      return typeof process !== "undefined" && process.versions !== undefined && process.versions.node !== undefined;
+    key: "consumeFromBuffer",
+    value: function consumeFromBuffer(bytes) {
+      var splitResult = this.splitBuffer(this.buffer, bytes);
+      if (splitResult === undefined) {
+        return undefined;
+      }
+      var _splitResult2 = _slicedToArray(splitResult, 2),
+        consumed = _splitResult2[0],
+        remaining = _splitResult2[1];
+      this.buffer = remaining;
+      return consumed;
     }
   }, {
-    key: "getUploadPart",
-    value: function getUploadPart(request, partIndex, uploadInfo) {
-      try {
-        var _this14 = this;
-        if (partIndex === 0) {
-          return uploadInfo.uploadParts.first;
-        }
-        return UploadManager_await(_this14.uploadApi.getUploadPart({
-          uploadId: uploadInfo.uploadId,
-          accountId: request.accountId,
-          uploadPartIndex: partIndex
-        }));
-      } catch (e) {
-        return Promise.reject(e);
+    key: "splitBuffer",
+    value: function splitBuffer(buffer, maxBytes) {
+      if (buffer.byteLength === 0) {
+        return undefined;
       }
+      var bytesToConsume = Math.min(maxBytes, buffer.byteLength);
+      if (bytesToConsume === buffer.byteLength) {
+        return [buffer, Buffer.alloc(0)]; // Optimization
+      }
+
+      var consumed = buffer.subarray(0, bytesToConsume);
+      var remaining = buffer.subarray(bytesToConsume);
+      return [consumed, remaining];
     }
-  }, {
-    key: "calculateSize",
-    value: function calculateSize(request, data) {
-      return this.foldData(data, {
-        ifBlob: function ifBlob(blob) {
-          return blob.size;
-        },
-        ifBuffer: function ifBuffer(buffer) {
-          return buffer.length;
-        },
-        ifNodeJsStream: function ifNodeJsStream(_) {
-          if (request.size === undefined) {
-            throw new Error("You must include the 'size' parameter when using a stream for the 'data' parameter.");
-          }
-          return request.size;
+  }]);
+  return NodeChunkedStream;
+}();
+;// CONCATENATED MODULE: ./src/uploads/private/TypeUtils.ts
+function assertUnreachable(x) {
+  throw new Error("Didn't expect to get here: ".concat(JSON.stringify(x)));
+}
+;// CONCATENATED MODULE: external "buffer"
+var external_buffer_x = y => { var x = {}; __lib_require__.d(x, y); return x; }
+var external_buffer_y = x => () => x
+var external_buffer_namespaceObject = external_buffer_x({ ["Blob"]: () => __WEBPACK_EXTERNAL_MODULE_buffer__.Blob });
+;// CONCATENATED MODULE: ./src/uploads/public/node/UploadManagerNode.ts
+function UploadManagerNode_typeof(obj) { "@babel/helpers - typeof"; return UploadManagerNode_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, UploadManagerNode_typeof(obj); }
+function UploadManagerNode_empty() {}
+function UploadManagerNode_awaitIgnored(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(UploadManagerNode_empty) : Promise.resolve();
+  }
+}
+function UploadManagerNode_await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function UploadManagerNode_settle(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof UploadManagerNode_Pact) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
         }
-      });
+        value = value.v;
+      } else {
+        value.o = UploadManagerNode_settle.bind(null, pact, state);
+        return;
+      }
     }
-  }, {
-    key: "calculateMime",
-    value: function calculateMime(request, data) {
-      var _a;
-      return (_a = request.mime) !== null && _a !== void 0 ? _a : this.foldData(data, {
-        ifBlob: function ifBlob(blob) {
-          return blob.type;
-        },
-        ifBuffer: function ifBuffer(_) {
-          return undefined;
-        },
-        ifNodeJsStream: function ifNodeJsStream(_) {
-          return undefined;
+    if (value && value.then) {
+      value.then(UploadManagerNode_settle.bind(null, pact, state), UploadManagerNode_settle.bind(null, pact, 2));
+      return;
+    }
+    pact.s = state;
+    pact.v = value;
+    var observer = pact.o;
+    if (observer) {
+      observer(pact);
+    }
+  }
+}
+var UploadManagerNode_Pact = /*#__PURE__*/function () {
+  function _Pact() {}
+  _Pact.prototype.then = function (onFulfilled, onRejected) {
+    var result = new _Pact();
+    var state = this.s;
+    if (state) {
+      var callback = state & 1 ? onFulfilled : onRejected;
+      if (callback) {
+        try {
+          UploadManagerNode_settle(result, 1, callback(this.v));
+        } catch (e) {
+          UploadManagerNode_settle(result, 2, e);
         }
-      });
+        return result;
+      } else {
+        return this;
+      }
     }
-  }, {
-    key: "calculateOriginalFileName",
-    value: function calculateOriginalFileName(request, data) {
-      var _a;
-      return (_a = request.originalFileName) !== null && _a !== void 0 ? _a : this.foldData(data, {
-        ifBlob: function ifBlob(blob) {
-          return blob.name;
-        },
-        ifBuffer: function ifBuffer(_) {
-          return undefined;
-        },
-        ifNodeJsStream: function ifNodeJsStream(_) {
-          return undefined;
+    this.o = function (_this) {
+      try {
+        var value = _this.v;
+        if (_this.s & 1) {
+          UploadManagerNode_settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+        } else if (onRejected) {
+          UploadManagerNode_settle(result, 1, onRejected(value));
+        } else {
+          UploadManagerNode_settle(result, 2, value);
         }
-      });
+      } catch (e) {
+        UploadManagerNode_settle(result, 2, e);
+      }
+    };
+    return result;
+  };
+  return _Pact;
+}();
+function _switch(discriminant, cases) {
+  var dispatchIndex = -1;
+  var awaitBody;
+  outer: {
+    for (var i = 0; i < cases.length; i++) {
+      var test = cases[i][0];
+      if (test) {
+        var testValue = test();
+        if (testValue && testValue.then) {
+          break outer;
+        }
+        if (testValue === discriminant) {
+          dispatchIndex = i;
+          break;
+        }
+      } else {
+        // Found the default case, set it as the pending dispatch case
+        dispatchIndex = i;
+      }
     }
-  }, {
-    key: "calculateMaxConcurrency",
-    value: function calculateMaxConcurrency(request, data) {
-      var _a;
-      return (_a = this.foldData(data, {
-        ifBlob: function ifBlob(_) {
-          return request.maxConcurrentUploadParts;
-        },
-        ifBuffer: function ifBuffer(_) {
-          return request.maxConcurrentUploadParts;
-        },
-        ifNodeJsStream: function ifNodeJsStream(_) {
-          return 1;
-        } // Uploading from a stream concurrently is more complex, as would require buffering parts in memory, so we serialize.
-      })) !== null && _a !== void 0 ? _a : this.defaultMaxConcurrentUploadParts;
+    if (dispatchIndex !== -1) {
+      do {
+        var body = cases[dispatchIndex][1];
+        while (!body) {
+          dispatchIndex++;
+          body = cases[dispatchIndex][1];
+        }
+        var result = body();
+        if (result && result.then) {
+          awaitBody = true;
+          break outer;
+        }
+        var fallthroughCheck = cases[dispatchIndex][2];
+        dispatchIndex++;
+      } while (fallthroughCheck && !fallthroughCheck());
+      return result;
     }
-  }, {
-    key: "getChunkedStream",
-    value: function getChunkedStream(data) {
-      return this.foldData(data, {
-        ifBlob: function ifBlob(_) {
-          return undefined;
-        },
-        ifBuffer: function ifBuffer(_) {
-          return undefined;
-        },
-        ifNodeJsStream: function ifNodeJsStream(x) {
-          return x;
+  }
+  var pact = new UploadManagerNode_Pact();
+  var reject = UploadManagerNode_settle.bind(null, pact, 2);
+  (awaitBody ? result.then(_resumeAfterBody) : testValue.then(_resumeAfterTest)).then(void 0, reject);
+  return pact;
+  function _resumeAfterTest(value) {
+    for (;;) {
+      if (value === discriminant) {
+        dispatchIndex = i;
+        break;
+      }
+      if (++i === cases.length) {
+        if (dispatchIndex !== -1) {
+          break;
+        } else {
+          UploadManagerNode_settle(pact, 1, result);
+          return;
         }
-      });
+      }
+      test = cases[i][0];
+      if (test) {
+        value = test();
+        if (value && value.then) {
+          value.then(_resumeAfterTest).then(void 0, reject);
+          return;
+        }
+      } else {
+        dispatchIndex = i;
+      }
     }
-  }, {
-    key: "foldData",
-    value: function foldData(data, handle) {
-      if (data instanceof ChunkedStream) {
-        return handle.ifNodeJsStream(data);
+    do {
+      var body = cases[dispatchIndex][1];
+      while (!body) {
+        dispatchIndex++;
+        body = cases[dispatchIndex][1];
+      }
+      var result = body();
+      if (result && result.then) {
+        result.then(_resumeAfterBody).then(void 0, reject);
+        return;
+      }
+      var fallthroughCheck = cases[dispatchIndex][2];
+      dispatchIndex++;
+    } while (fallthroughCheck && !fallthroughCheck());
+    UploadManagerNode_settle(pact, 1, result);
+  }
+  function _resumeAfterBody(result) {
+    for (;;) {
+      var fallthroughCheck = cases[dispatchIndex][2];
+      if (!fallthroughCheck || fallthroughCheck()) {
+        break;
+      }
+      dispatchIndex++;
+      var body = cases[dispatchIndex][1];
+      while (!body) {
+        dispatchIndex++;
+        body = cases[dispatchIndex][1];
+      }
+      result = body();
+      if (result && result.then) {
+        result.then(_resumeAfterBody).then(void 0, reject);
+        return;
+      }
+    }
+    UploadManagerNode_settle(pact, 1, result);
+  }
+}
+function UploadManagerNode_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UploadManagerNode_defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, UploadManagerNode_toPropertyKey(descriptor.key), descriptor); } }
+function UploadManagerNode_createClass(Constructor, protoProps, staticProps) { if (protoProps) UploadManagerNode_defineProperties(Constructor.prototype, protoProps); if (staticProps) UploadManagerNode_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UploadManagerNode_toPropertyKey(arg) { var key = UploadManagerNode_toPrimitive(arg, "string"); return UploadManagerNode_typeof(key) === "symbol" ? key : String(key); }
+function UploadManagerNode_toPrimitive(input, hint) { if (UploadManagerNode_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UploadManagerNode_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function UploadManagerNode_inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) UploadManagerNode_setPrototypeOf(subClass, superClass); }
+function UploadManagerNode_setPrototypeOf(o, p) { UploadManagerNode_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return UploadManagerNode_setPrototypeOf(o, p); }
+function UploadManagerNode_createSuper(Derived) { var hasNativeReflectConstruct = UploadManagerNode_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = UploadManagerNode_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = UploadManagerNode_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return UploadManagerNode_possibleConstructorReturn(this, result); }; }
+function UploadManagerNode_possibleConstructorReturn(self, call) { if (call && (UploadManagerNode_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return UploadManagerNode_assertThisInitialized(self); }
+function UploadManagerNode_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function UploadManagerNode_isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function UploadManagerNode_getPrototypeOf(o) { UploadManagerNode_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return UploadManagerNode_getPrototypeOf(o); }
+
+
+
+
+
+var UploadManager = /*#__PURE__*/function (_UploadManagerBase) {
+  UploadManagerNode_inherits(UploadManager, _UploadManagerBase);
+  var _super = UploadManagerNode_createSuper(UploadManager);
+  function UploadManager() {
+    UploadManagerNode_classCallCheck(this, UploadManager);
+    return _super.apply(this, arguments);
+  }
+  UploadManagerNode_createClass(UploadManager, [{
+    key: "processUploadSource",
+    value: function processUploadSource(data) {
+      if (typeof data === "string") {
+        // 'Blob' must be from 'buffer' as we're in a node context here, so isn't globally available.
+        return {
+          type: "Blob",
+          value: new external_buffer_namespaceObject.Blob([data], {
+            type: this.stringMimeType
+          })
+        };
+      }
+      if (data.on !== undefined) {
+        return {
+          type: "Stream",
+          value: new NodeChunkedStream(data)
+        };
       }
       if (data.subarray !== undefined) {
-        return handle.ifBuffer(data);
+        return {
+          type: "Buffer",
+          value: data
+        };
       }
-      if (data.slice !== undefined) {
-        return handle.ifBlob(data);
+      if (data.size !== undefined) {
+        return {
+          type: "Blob",
+          value: data
+        };
       }
       throw new Error("Unsupported type for 'data' parameter. Please provide a String, Blob, or Readable (Node.js).");
     }
   }, {
-    key: "foldDataRaw",
-    value: function foldDataRaw(data, handle) {
-      try {
-        var _exit8 = false;
-        var _this16 = this;
-        return UploadManager_invoke(function () {
-          if (typeof data === "string") {
-            _exit8 = true;
-            var _ifBlob2 = handle.ifBlob;
-            return UploadManager_await(_this16.stringToBlob(data), function (_this15$stringToBlob) {
-              return UploadManager_await(_ifBlob2.call(handle, _this15$stringToBlob));
-            });
+    key: "getPreUploadInfoPartial",
+    value: function getPreUploadInfoPartial(request, data) {
+      switch (data.type) {
+        case "Blob":
+          return this.getBlobInfo(data);
+        case "Buffer":
+          return {
+            mime: undefined,
+            size: data.value.length,
+            originalFileName: undefined,
+            maxConcurrentUploadParts: undefined
+          };
+        case "Stream":
+          if (request.size === undefined) {
+            throw new Error("You must include the 'size' parameter when using a stream for the 'data' parameter.");
           }
-        }, function (_result3) {
-          var _exit5 = false;
-          if (_exit8) return _result3;
-          return UploadManager_invoke(function () {
-            if (data.on !== undefined) {
-              _exit5 = true;
-              return UploadManager_await(handle.ifNodeJsStream(data));
-            }
-          }, function (_result4) {
-            var _exit6 = false;
-            if (_exit5) return _result4;
-            return UploadManager_invoke(function () {
-              if (data.subarray !== undefined) {
-                _exit6 = true;
-                return UploadManager_await(handle.ifBuffer(data));
-              }
-            }, function (_result5) {
-              var _exit7 = false;
-              if (_exit6) return _result5;
-              return UploadManager_invoke(function () {
-                if (data.slice !== undefined) {
-                  _exit7 = true;
-                  return UploadManager_await(handle.ifBlob(data));
-                }
-              }, function (_result6) {
-                if (_exit7) return _result6;
-                throw new Error("Unsupported type for 'data' parameter. Please provide a String, Blob, or Readable (Node.js).");
-              });
-            });
-          });
-        });
-      } catch (e) {
-        return Promise.reject(e);
+          return {
+            mime: undefined,
+            size: request.size,
+            originalFileName: undefined,
+            maxConcurrentUploadParts: 1 // Uploading from a stream concurrently is complex, so we serialize it.
+          };
+
+        default:
+          assertUnreachable(data);
       }
     }
   }, {
-    key: "processUploadSource",
-    value: function processUploadSource(data) {
-      try {
-        var _exit10 = false;
-        var _this18 = this;
-        return UploadManager_invoke(function () {
-          if (typeof data === "string") {
-            _exit10 = true;
-            return UploadManager_await(_this18.stringToBlob(data));
-          }
-        }, function (_result7) {
-          if (_exit10) return _result7;
-          if (data.on !== undefined) {
-            return new ChunkedStream(data);
-          }
-          if (data.subarray !== undefined) {
-            return data;
-          }
-          if (data.slice !== undefined) {
-            return data;
-          }
-          throw new Error("Unsupported type for 'data' parameter. Please provide a String, Blob, or Readable (Node.js).");
-        });
-      } catch (e) {
-        return Promise.reject(e);
+    key: "preUpload",
+    value: function preUpload(source) {
+      if (source.type !== "Stream") {
+        return undefined;
       }
+      var chunkedStream = source.value;
+      var chunkedStreamPromise = chunkedStream.runChunkPipeline();
+      return {
+        chunkedStreamPromise: chunkedStreamPromise,
+        chunkedStream: chunkedStream
+      };
     }
   }, {
-    key: "stringToBlob",
-    value: function stringToBlob(data) {
+    key: "postUpload",
+    value: function postUpload(init) {
       try {
-        var _this20 = this;
-        var _a;
-        var _temp2 = (_a = _this20.globalBlob(data)) !== null && _a !== void 0;
-        return UploadManager_await(_temp2 ? _a : _this20.nodeJsBlob(data), void 0, _temp2);
+        if (init === undefined) {
+          return;
+        }
+        init.chunkedStream.finishedConsuming();
+        // Raise any errors from the stream chunking task.
+        return UploadManagerNode_awaitIgnored(init.chunkedStreamPromise);
       } catch (e) {
         return Promise.reject(e);
       }
-    } // Supported by browsers & newer versions of Node.js.
-  }, {
-    key: "globalBlob",
-    value: function globalBlob(data) {
-      var B = globalThis.Blob;
-      if (B === undefined) {
-        return undefined;
-      }
-      return new B([data], {
-        type: this.stringMimeType
-      });
     }
-    // Fallback for Node.js
   }, {
-    key: "nodeJsBlob",
-    value: function nodeJsBlob(data) {
+    key: "doPutUploadPart",
+    value: function doPutUploadPart(part, contentLength, source, onProgress, addCancellationHandler) {
       try {
-        var _this22 = this;
-        return UploadManager_await(NodeUtils.createBlob([data], {
-          type: _this22.stringMimeType
-        }));
+        var _this2 = this;
+        var _a, _b;
+        var fetchApi = (_a = _this2.config.fetchApi) !== null && _a !== void 0 ? _a : fetch;
+        var headers = {
+          // Required to prevent fetch using "Transfer-Encoding: Chunked" when body is a stream.
+          "content-length": contentLength.toString()
+        };
+        // Configure cancellation:
+        var controller = new AbortController();
+        var signal = controller.signal;
+        addCancellationHandler(function () {
+          return controller.abort();
+        });
+        // Report progress:
+        var hasWarned = false;
+        return UploadManagerNode_await(_this2.sliceDataForRequest(source, part), function (stream) {
+          var streamWithProgress = stream.on("data", function (data) {
+            if (data.length !== undefined) {
+              onProgress(data.length);
+            } else if (!hasWarned) {
+              hasWarned = true;
+              console.warn("Expected stream to contain buffers, but it did not, so upload progress won't be reported.");
+            }
+          });
+          return UploadManagerNode_await(fetchApi(part.uploadUrl, {
+            method: "PUT",
+            headers: headers,
+            body: _this2.coerceRequestBody(streamWithProgress),
+            signal: signal
+          }), function (response) {
+            return {
+              etag: (_b = response.headers.get("etag")) !== null && _b !== void 0 ? _b : undefined,
+              status: response.status
+            };
+          });
+        });
       } catch (e) {
         return Promise.reject(e);
       }
     }
   }, {
-    key: "mapAsync",
-    value: function mapAsync(items, concurrency, callback) {
+    key: "coerceRequestBody",
+    value: function coerceRequestBody(data) {
+      return data; // node-fetch supports 'NodeJS.ReadableStream'
+    }
+  }, {
+    key: "sliceDataForRequest",
+    value: function sliceDataForRequest(data, part) {
       try {
-        var workQueue = _toConsumableArray(items);
-        return _awaitIgnored(Promise.all(_toConsumableArray(Array(concurrency).keys()).map(UploadManager_async(function () {
-          return _continueIgnored(_for(function () {
-            return workQueue.length > 0;
-          }, void 0, function () {
-            var work = workQueue.shift(); // IMPORTANT: use 'shift' instead of 'pop' to ensure 'items' are processed in order when 'concurrency = 1'.
-            return _invokeIgnored(function () {
-              if (work !== undefined) {
-                return _awaitIgnored(callback(work));
-              }
-            });
-          }));
-        }))));
+        if (part.range.inclusiveEnd === -1) {
+          return StreamUtils.empty();
+        }
+        var start = part.range.inclusiveStart;
+        var endExclusive = part.range.inclusiveEnd + 1;
+        var partSize = endExclusive - start;
+        return _switch(data.type, [[function () {
+          return "Blob";
+        }, function () {
+          var _fromBuffer = StreamUtils.fromBuffer,
+            _Buffer = Buffer,
+            _from = _Buffer.from;
+          return UploadManagerNode_await(data.value.slice(start, endExclusive).arrayBuffer(), function (_data$value$slice$arr) {
+            return _fromBuffer.call(StreamUtils, _from.call(_Buffer, _data$value$slice$arr));
+          });
+        }], [function () {
+          return "Buffer";
+        }, function () {
+          return StreamUtils.fromBuffer(data.value.subarray(start, endExclusive));
+        }], [function () {
+          return "Stream";
+        }, function () {
+          return data.value.take(partSize);
+        }], [void 0, function () {
+          assertUnreachable(data);
+        }, UploadManagerNode_empty]]);
       } catch (e) {
         return Promise.reject(e);
       }
     }
   }]);
   return UploadManager;
-}();
-;// CONCATENATED MODULE: ./src/uploads/index.ts
-
+}(UploadManagerBase);
+;// CONCATENATED MODULE: ./src/uploads/public/node/index.ts
 
-
-;// CONCATENATED MODULE: ./src/index.ts
+;// CONCATENATED MODULE: ./src/index.node.ts
 /* tslint:disable */
 /* eslint-disable */
 
 
-}();
+
 var __lib_exports__BASE_PATH = __lib_exports__.BASE_PATH;
 var __lib_exports__BaseAPI = __lib_exports__.BaseAPI;
 var __lib_exports__BinaryResult = __lib_exports__.BinaryResult;
 var __lib_exports__BytescaleApiError = __lib_exports__.BytescaleApiError;
 var __lib_exports__CancelledError = __lib_exports__.CancelledError;
-var __lib_exports__ChunkedStream = __lib_exports__.ChunkedStream;
-var __lib_exports__FetchError = __lib_exports__.FetchError;
 var __lib_exports__FileApi = __lib_exports__.FileApi;
 var __lib_exports__FolderApi = __lib_exports__.FolderApi;
 var __lib_exports__JSONApiResponse = __lib_exports__.JSONApiResponse;
 var __lib_exports__JobApi = __lib_exports__.JobApi;
-var __lib_exports__RequiredError = __lib_exports__.RequiredError;
-var __lib_exports__ResponseError = __lib_exports__.ResponseError;
 var __lib_exports__UploadApi = __lib_exports__.UploadApi;
 var __lib_exports__UploadManager = __lib_exports__.UploadManager;
 var __lib_exports__VoidApiResponse = __lib_exports__.VoidApiResponse;
 var __lib_exports__querystring = __lib_exports__.querystring;
-export { __lib_exports__BASE_PATH as BASE_PATH, __lib_exports__BaseAPI as BaseAPI, __lib_exports__BinaryResult as BinaryResult, __lib_exports__BytescaleApiError as BytescaleApiError, __lib_exports__CancelledError as CancelledError, __lib_exports__ChunkedStream as ChunkedStream, __lib_exports__FetchError as FetchError, __lib_exports__FileApi as FileApi, __lib_exports__FolderApi as FolderApi, __lib_exports__JSONApiResponse as JSONApiResponse, __lib_exports__JobApi as JobApi, __lib_exports__RequiredError as RequiredError, __lib_exports__ResponseError as ResponseError, __lib_exports__UploadApi as UploadApi, __lib_exports__UploadManager as UploadManager, __lib_exports__VoidApiResponse as VoidApiResponse, __lib_exports__querystring as querystring };
+export { __lib_exports__BASE_PATH as BASE_PATH, __lib_exports__BaseAPI as BaseAPI, __lib_exports__BinaryResult as BinaryResult, __lib_exports__BytescaleApiError as BytescaleApiError, __lib_exports__CancelledError as CancelledError, __lib_exports__FileApi as FileApi, __lib_exports__FolderApi as FolderApi, __lib_exports__JSONApiResponse as JSONApiResponse, __lib_exports__JobApi as JobApi, __lib_exports__UploadApi as UploadApi, __lib_exports__UploadManager as UploadManager, __lib_exports__VoidApiResponse as VoidApiResponse, __lib_exports__querystring as querystring };