@bytescale/sdk 1.1.0 → 1.3.0

package/dist/node/cjs/main.js

@@ -22,79 +22,10 @@
 //
 /******/ (function() { // webpackBootstrap
 /******/ 	"use strict";
-/******/ 	var __lib_modules__ = ({
-
-/***/ "buffer":
-/***/ (function(module) {
-
-module.exports = require("buffer");
-
-/***/ }),
-
-/***/ "stream":
-/***/ (function(module) {
-
-module.exports = require("stream");
-
-/***/ })
-
-/******/ 	});
-/************************************************************************/
-/******/ 	// The module cache
-/******/ 	var __lib_module_cache__ = {};
-/******/ 	
-/******/ 	// The require function
-/******/ 	function __lib_require__(moduleId) {
-/******/ 		// Check if module is in cache
-/******/ 		var cachedModule = __lib_module_cache__[moduleId];
-/******/ 		if (cachedModule !== undefined) {
-/******/ 			return cachedModule.exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = __lib_module_cache__[moduleId] = {
-/******/ 			// no module.id needed
-/******/ 			// no module.loaded needed
-/******/ 			exports: {}
-/******/ 		};
-/******/ 	
-/******/ 		// Execute the module function
-/******/ 		__lib_modules__[moduleId](module, module.exports, __lib_require__);
-/******/ 	
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
+/******/ 	// The require scope
+/******/ 	var __lib_require__ = {};
 /******/ 	
 /************************************************************************/
-/******/ 	/* webpack/runtime/create fake namespace object */
-/******/ 	!function() {
-/******/ 		var getProto = Object.getPrototypeOf ? function(obj) { return Object.getPrototypeOf(obj); } : function(obj) { return obj.__proto__; };
-/******/ 		var leafPrototypes;
-/******/ 		// create a fake namespace object
-/******/ 		// mode & 1: value is a module id, require it
-/******/ 		// mode & 2: merge all properties of value into the ns
-/******/ 		// mode & 4: return value when already ns object
-/******/ 		// mode & 16: return value when it's Promise-like
-/******/ 		// mode & 8|1: behave like require
-/******/ 		__lib_require__.t = function(value, mode) {
-/******/ 			if(mode & 1) value = this(value);
-/******/ 			if(mode & 8) return value;
-/******/ 			if(typeof value === 'object' && value) {
-/******/ 				if((mode & 4) && value.__esModule) return value;
-/******/ 				if((mode & 16) && typeof value.then === 'function') return value;
-/******/ 			}
-/******/ 			var ns = Object.create(null);
-/******/ 			__lib_require__.r(ns);
-/******/ 			var def = {};
-/******/ 			leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
-/******/ 			for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {
-/******/ 				Object.getOwnPropertyNames(current).forEach(function(key) { def[key] = function() { return value[key]; }; });
-/******/ 			}
-/******/ 			def['default'] = function() { return value; };
-/******/ 			__lib_require__.d(ns, def);
-/******/ 			return ns;
-/******/ 		};
-/******/ 	}();
-/******/ 	
 /******/ 	/* webpack/runtime/define property getters */
 /******/ 	!function() {
 /******/ 		// define getter functions for harmony exports
@@ -125,37 +56,45 @@ module.exports = require("stream");
 /******/ 	
 /************************************************************************/
 var __lib_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
-!function() {
 // ESM COMPAT FLAG
 __lib_require__.r(__lib_exports__);
 
 // EXPORTS
 __lib_require__.d(__lib_exports__, {
-  "BASE_PATH": function() { return /* reexport */ BASE_PATH; },
+  "AuthManager": function() { return /* reexport */ AuthManager; },
   "BaseAPI": function() { return /* reexport */ BaseAPI; },
   "BinaryResult": function() { return /* reexport */ BinaryResult; },
+  "BytescaleApiClientConfigResolver": function() { return /* reexport */ BytescaleApiClientConfigResolver; },
   "BytescaleApiError": function() { return /* reexport */ BytescaleApiError; },
   "CancelledError": function() { return /* reexport */ CancelledError; },
-  "ChunkedStream": function() { return /* reexport */ ChunkedStream; },
-  "FetchError": function() { return /* reexport */ FetchError; },
+  "CommonTypesNoOp": function() { return /* reexport */ CommonTypesNoOp; },
   "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; },
+  "UrlBuilder": function() { return /* reexport */ UrlBuilder; },
+  "UrlBuilderTypesNoOp": function() { return /* reexport */ UrlBuilderTypesNoOp; },
   "VoidApiResponse": function() { return /* reexport */ VoidApiResponse; },
   "querystring": function() { return /* reexport */ querystring; }
 });
 
-;// CONCATENATED MODULE: ./src/generated/runtime.ts
+;// CONCATENATED MODULE: ./src/private/AuthSessionState.ts
 function _typeof(obj) { "@babel/helpers - typeof"; return _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; }, _typeof(obj); }
+function _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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+var AuthSessionState = /*#__PURE__*/_createClass(function AuthSessionState() {
+  _classCallCheck(this, AuthSessionState);
+});
+;// CONCATENATED MODULE: ./src/public/shared/generated/runtime.ts
+function runtime_typeof(obj) { "@babel/helpers - typeof"; return runtime_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; }, runtime_typeof(obj); }
 function _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) _setPrototypeOf(subClass, superClass); }
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_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 _assertThisInitialized(self); }
+function _possibleConstructorReturn(self, call) { if (call && (runtime_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 _assertThisInitialized(self); }
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_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 _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
 function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _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) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
@@ -163,15 +102,6 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-function _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 _catch(body, recover) {
   try {
     var result = body();
@@ -183,22 +113,10 @@ function _catch(body, recover) {
   }
   return result;
 }
+function _empty() {}
 function _continue(value, then) {
   return value && value.then ? value.then(then) : then(value);
 }
-function _async(f) {
-  return function () {
-    for (var args = [], i = 0; i < arguments.length; i++) {
-      args[i] = arguments[i];
-    }
-    try {
-      return Promise.resolve(f.apply(this, args));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-}
-function _empty() {}
 function _invoke(body, then) {
   var result = body();
   if (result && result.then) {
@@ -206,85 +124,122 @@ function _invoke(body, then) {
   }
   return then(result);
 }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _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, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-/**
- * @bytescale/api
- * Bytescale API
- *
- * The version of the OpenAPI document: 2.0.0
- * Contact: hello@bytescale.com
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-var BASE_PATH = "https://api.bytescale.com".replace(/\/+$/, "");
+function _defineProperty(obj, key, value) { key = runtime_toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _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 runtime_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function runtime_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, runtime_toPropertyKey(descriptor.key), descriptor); } }
+function runtime_createClass(Constructor, protoProps, staticProps) { if (protoProps) runtime_defineProperties(Constructor.prototype, protoProps); if (staticProps) runtime_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function runtime_toPropertyKey(arg) { var key = runtime_toPrimitive(arg, "string"); return runtime_typeof(key) === "symbol" ? key : String(key); }
+function runtime_toPrimitive(input, hint) { if (runtime_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (runtime_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+var BytescaleApiClientConfigResolver = /*#__PURE__*/function () {
+  function BytescaleApiClientConfigResolver() {
+    runtime_classCallCheck(this, BytescaleApiClientConfigResolver);
+  }
+  runtime_createClass(BytescaleApiClientConfigResolver, null, [{
+    key: "getApiUrl",
+    value: function getApiUrl(config) {
+      var _a;
+      return (_a = config.apiUrl) !== null && _a !== void 0 ? _a : BytescaleApiClientConfigResolver.defaultApiUrl;
+    }
+  }, {
+    key: "getCdnUrl",
+    value: function getCdnUrl(config) {
+      var _a;
+      return (_a = config.cdnUrl) !== null && _a !== void 0 ? _a : BytescaleApiClientConfigResolver.defaultCdnUrl;
+    }
+  }, {
+    key: "getFetchApi",
+    value: function getFetchApi(config) {
+      var _a;
+      return (_a = config.fetchApi) !== null && _a !== void 0 ? _a : fetch;
+    }
+  }]);
+  return BytescaleApiClientConfigResolver;
+}();
+BytescaleApiClientConfigResolver.defaultApiUrl = "https://api.bytescale.com";
+BytescaleApiClientConfigResolver.defaultCdnUrl = "https://upcdn.io";
 /**
  * This is the base class for all generated API classes.
  */
 var BaseAPI = /*#__PURE__*/function () {
   function BaseAPI(config) {
-    var _this = this;
-    _classCallCheck(this, BaseAPI);
+    runtime_classCallCheck(this, BaseAPI);
     this.config = config;
-    this.fetchApi = _async(function (url, init) {
-      var _exit = false;
-      var fetchParams = {
-        url: url,
-        init: init
-      };
-      var response = undefined;
-      return _continue(_catch(function () {
-        return _await((_this.config.fetchApi || fetch)(fetchParams.url, fetchParams.init), function (_temp) {
-          response = _temp;
-        });
-      }, 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;
-          }
-        }
-      }), function (_result) {
-        return _exit ? _result : response;
-      });
-    });
   }
-  _createClass(BaseAPI, [{
+  runtime_createClass(BaseAPI, [{
     key: "request",
-    value: function request(context, initOverrides, operationBasePathOverride) {
+    value: function request(context, initOverrides, baseUrlOverride) {
       try {
-        var _this3 = this;
-        var _a;
-        var apiKey = _this3.config.apiKey;
+        var _this2 = this;
+        var _a, _b;
+        var apiKey = _this2.config.apiKey;
         context.headers["Authorization"] = "Bearer ".concat(apiKey); // authorization-header authentication
-        return _await(_this3.createFetchParams(context, initOverrides, operationBasePathOverride), function (_ref) {
+        if (((_a = AuthSessionState.session) === null || _a === void 0 ? void 0 : _a.accessToken) !== undefined) {
+          context.headers["Authorization-Token"] = AuthSessionState.session.accessToken;
+        }
+        // Key: any possible value for 'baseUrlOverride'
+        // Value: user-overridden value for that base URL from the config.
+        var nonDefaultBasePaths = _defineProperty({}, BytescaleApiClientConfigResolver.defaultCdnUrl, BytescaleApiClientConfigResolver.getCdnUrl(_this2.config));
+        return _await(_this2.createFetchParams(context, initOverrides, baseUrlOverride === undefined ? undefined : (_b = nonDefaultBasePaths[baseUrlOverride]) !== null && _b !== void 0 ? _b : baseUrlOverride), function (_ref) {
           var url = _ref.url,
             init = _ref.init;
-          return _await(_this3.fetchApi(url, init), function (response) {
-            var _exit2 = false;
-            return response && response.status >= 200 && response.status < 300 ? response : _invoke(function () {
-              if (response !== undefined) {
-                var jsonError = undefined;
-                return _continue(_catch(function () {
-                  return _await(response.json(), function (_response$json) {
-                    jsonError = _response$json;
-                  });
-                }, _empty), function () {
-                  if (typeof ((_a = jsonError === null || jsonError === void 0 ? void 0 : jsonError.error) === null || _a === void 0 ? void 0 : _a.code) === "string") {
-                    throw new BytescaleApiError(jsonError);
-                  }
+          return _this2.doFetch(url, init, true);
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Returns a successful response (2**) else throws an error.
+     */
+  }, {
+    key: "doFetch",
+    value: function doFetch(url, init, isBytescaleApi) {
+      try {
+        var _exit3 = false;
+        var _this4 = this;
+        var _a, _b;
+        var response;
+        return _continue(_catch(function () {
+          return _await(BytescaleApiClientConfigResolver.getFetchApi(_this4.config)(url, init), function (_BytescaleApiClientCo) {
+            response = _BytescaleApiClientCo;
+          });
+        }, function (e) {
+          // Network-level errors, CORS errors, or HTTP-level errors from intermediary services (e.g. AWS or the user's own infrastructure/proxies).
+          // HTTP-level errors from external services (e.g. AWS or the user's own proxy) will appear as CORS errors as their response headers won't include the appropriate CORS values.
+          throw new Error(isBytescaleApi ? "Unable to resolve the Bytescale API: ".concat(e.message, " If the problem persists, and your network connection is OK, then please contact support@bytescale.com and provide: (a) time of failed request in UTC (b) screenshot of failed network response header + body (c) screenshot of failed network request header + body (d) browser and OS version.") : "Unable to resolve URL (".concat(url, "): ").concat(e.message));
+        }), function (_result) {
+          var _exit2 = false;
+          if (_exit3) return _result;
+          return response.status >= 200 && response.status < 300 ? response : _invoke(function () {
+            if (isBytescaleApi) {
+              var jsonError = undefined;
+              return _continue(_catch(function () {
+                return _await(response.json(), function (_response$json) {
+                  jsonError = _response$json;
                 });
-              }
-            }, function (_result2) {
-              if (_exit2) return _result2;
-              throw new ResponseError(response, "Response returned an error code");
-            });
+              }, _empty), function () {
+                if (typeof ((_a = jsonError === null || jsonError === void 0 ? void 0 : jsonError.error) === null || _a === void 0 ? void 0 : _a.code) === "string") {
+                  throw new BytescaleApiError(jsonError);
+                }
+                // HTTP-level errors from intermediary services (e.g. AWS or the user's own infrastructure/proxies). On the browser,
+                // this error is unlikely to be triggered since these errors will masqurade as CORS errors (see above) but in Node.js
+                // this error will appear from any intermediary service failure.
+                throw new Error("Unable to connect to the Bytescale API (".concat(response.status, "): please try again."));
+              });
+            }
+          }, function (_result2) {
+            if (_exit2) return _result2;
+            throw new Error("Failure status code (".concat(response.status, ") received for request: ").concat((_b = init.method) !== null && _b !== void 0 ? _b : "GET", " ").concat(url));
           });
         });
       } catch (e) {
@@ -306,17 +261,17 @@ var BaseAPI = /*#__PURE__*/function () {
     }
   }, {
     key: "createFetchParams",
-    value: function createFetchParams(context, initOverrides, operationBasePathOverride) {
+    value: function createFetchParams(context, initOverrides, baseUrlOverride) {
       try {
-        var _this5 = this;
-        var url = (operationBasePathOverride !== null && operationBasePathOverride !== void 0 ? operationBasePathOverride : BASE_PATH) + context.path;
+        var _this6 = this;
+        var url = (baseUrlOverride !== null && baseUrlOverride !== void 0 ? baseUrlOverride : BytescaleApiClientConfigResolver.getApiUrl(_this6.config)) + context.path;
         if (context.query !== undefined && Object.keys(context.query).length !== 0) {
           // only add the querystring to the URL if there are query parameters.
           // this is done to avoid urls ending with a "?" character which buggy webservers
           // do not handle correctly sometimes.
           url += "?" + querystring(context.query);
         }
-        var configHeaders = _this5.config.headers;
+        var configHeaders = _this6.config.headers;
         var _Object$assign3 = Object.assign({}, context.headers);
         return _await(configHeaders === undefined ? {} : configHeaders(), function (_configHeaders) {
           var headers = Object.assign(_Object$assign3, _configHeaders);
@@ -338,7 +293,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,
@@ -353,64 +308,34 @@ 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);
-  function BytescaleApiError(response) {
-    var _this6;
-    _classCallCheck(this, BytescaleApiError);
-    _this6 = _super.call(this, response.error.message);
-    _this6.name = "BytescaleApiError";
-    _this6.errorCode = response.error.code;
-    _this6.details = response.error.details;
-    return _this6;
-  }
-  return _createClass(BytescaleApiError);
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-var ResponseError = /*#__PURE__*/function (_Error2) {
-  _inherits(ResponseError, _Error2);
-  var _super2 = _createSuper(ResponseError);
-  function ResponseError(response, msg) {
+BaseAPI.specialApiKeys = ["free", "demo"];
+BaseAPI.specialApiKeyAccountId = "W142hJk";
+BaseAPI.accountIdLength = 7; // Sync with: upload/shared/**/AccountIdUtils
+var CancelledError = /*#__PURE__*/function (_Error) {
+  _inherits(CancelledError, _Error);
+  var _super = _createSuper(CancelledError);
+  function CancelledError() {
     var _this7;
-    _classCallCheck(this, ResponseError);
-    _this7 = _super2.call(this, msg);
-    _this7.response = response;
-    _this7.name = "ResponseError";
+    runtime_classCallCheck(this, CancelledError);
+    _this7 = _super.call(this, "Operation cancelled by caller.");
+    _this7.name = "CancelledError";
     return _this7;
   }
-  return _createClass(ResponseError);
+  return runtime_createClass(CancelledError);
 }( /*#__PURE__*/_wrapNativeSuper(Error));
-var FetchError = /*#__PURE__*/function (_Error3) {
-  _inherits(FetchError, _Error3);
-  var _super3 = _createSuper(FetchError);
-  function FetchError(cause, msg) {
+var BytescaleApiError = /*#__PURE__*/function (_Error2) {
+  _inherits(BytescaleApiError, _Error2);
+  var _super2 = _createSuper(BytescaleApiError);
+  function BytescaleApiError(response) {
     var _this8;
-    _classCallCheck(this, FetchError);
-    _this8 = _super3.call(this, msg);
-    _this8.cause = cause;
-    _this8.name = "FetchError";
+    runtime_classCallCheck(this, BytescaleApiError);
+    _this8 = _super2.call(this, response.error.message);
+    _this8.name = "BytescaleApiError";
+    _this8.errorCode = response.error.code;
+    _this8.details = response.error.details;
     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);
+  return runtime_createClass(BytescaleApiError);
 }( /*#__PURE__*/_wrapNativeSuper(Error));
 function querystring(params) {
   var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
@@ -443,22 +368,15 @@ function querystringSingleKey(key, value) {
 }
 var JSONApiResponse = /*#__PURE__*/function () {
   function JSONApiResponse(raw) {
-    var transformer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (jsonValue) {
-      return jsonValue;
-    };
-    _classCallCheck(this, JSONApiResponse);
+    runtime_classCallCheck(this, JSONApiResponse);
     this.raw = raw;
-    this.transformer = transformer;
   }
-  _createClass(JSONApiResponse, [{
+  runtime_createClass(JSONApiResponse, [{
     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 _this10 = this;
+        return _await(_this10.raw.json());
       } catch (e) {
         return Promise.reject(e);
       }
@@ -468,10 +386,10 @@ var JSONApiResponse = /*#__PURE__*/function () {
 }();
 var VoidApiResponse = /*#__PURE__*/function () {
   function VoidApiResponse(raw) {
-    _classCallCheck(this, VoidApiResponse);
+    runtime_classCallCheck(this, VoidApiResponse);
     this.raw = raw;
   }
-  _createClass(VoidApiResponse, [{
+  runtime_createClass(VoidApiResponse, [{
     key: "value",
     value: function value() {
       return _await(undefined);
@@ -481,10 +399,10 @@ var VoidApiResponse = /*#__PURE__*/function () {
 }();
 var BinaryResult = /*#__PURE__*/function () {
   function BinaryResult(raw) {
-    _classCallCheck(this, BinaryResult);
+    runtime_classCallCheck(this, BinaryResult);
     this.raw = raw;
   }
-  _createClass(BinaryResult, [{
+  runtime_createClass(BinaryResult, [{
     key: "stream",
     value: function stream() {
       if (this.raw.bodyUsed) {
@@ -499,8 +417,8 @@ var BinaryResult = /*#__PURE__*/function () {
     key: "text",
     value: function text() {
       try {
-        var _this13 = this;
-        return _await(_this13.raw.text());
+        var _this12 = this;
+        return _await(_this12.raw.text());
       } catch (e) {
         return Promise.reject(e);
       }
@@ -509,8 +427,8 @@ var BinaryResult = /*#__PURE__*/function () {
     key: "blob",
     value: function blob() {
       try {
-        var _this15 = this;
-        return _await(_this15.raw.blob());
+        var _this14 = this;
+        return _await(_this14.raw.blob());
       } catch (e) {
         return Promise.reject(e);
       }
@@ -519,8 +437,8 @@ var BinaryResult = /*#__PURE__*/function () {
     key: "json",
     value: function json() {
       try {
-        var _this17 = this;
-        return _await(_this17.raw.json());
+        var _this16 = this;
+        return _await(_this16.raw.json());
       } catch (e) {
         return Promise.reject(e);
       }
@@ -528,7 +446,7 @@ var BinaryResult = /*#__PURE__*/function () {
   }]);
   return BinaryResult;
 }();
-;// CONCATENATED MODULE: ./src/generated/apis/FileApi.ts
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/FileApi.ts
 function FileApi_typeof(obj) { "@babel/helpers - typeof"; return FileApi_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; }, FileApi_typeof(obj); }
 function FileApi_await(value, then, direct) {
   if (direct) {
@@ -823,7 +741,7 @@ var FileApi = /*#__PURE__*/function (_runtime$BaseAPI) {
   }]);
   return FileApi;
 }(BaseAPI);
-;// CONCATENATED MODULE: ./src/generated/apis/FolderApi.ts
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/FolderApi.ts
 function FolderApi_typeof(obj) { "@babel/helpers - typeof"; return FolderApi_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; }, FolderApi_typeof(obj); }
 function FolderApi_await(value, then, direct) {
   if (direct) {
@@ -1083,7 +1001,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
   }]);
   return FolderApi;
 }(BaseAPI);
-;// CONCATENATED MODULE: ./src/generated/apis/JobApi.ts
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/JobApi.ts
 function JobApi_typeof(obj) { "@babel/helpers - typeof"; return JobApi_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; }, JobApi_typeof(obj); }
 function JobApi_await(value, then, direct) {
   if (direct) {
@@ -1218,7 +1136,7 @@ var JobApi = /*#__PURE__*/function (_runtime$BaseAPI) {
   }]);
   return JobApi;
 }(BaseAPI);
-;// CONCATENATED MODULE: ./src/generated/apis/UploadApi.ts
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/UploadApi.ts
 function UploadApi_typeof(obj) { "@babel/helpers - typeof"; return UploadApi_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; }, UploadApi_typeof(obj); }
 function UploadApi_await(value, then, direct) {
   if (direct) {
@@ -1406,366 +1324,198 @@ var UploadApi = /*#__PURE__*/function (_runtime$BaseAPI) {
   }]);
   return UploadApi;
 }(BaseAPI);
-;// CONCATENATED MODULE: ./src/generated/apis/index.ts
+;// CONCATENATED MODULE: ./src/public/shared/generated/apis/index.ts
 /* tslint:disable */
 /* eslint-disable */
 
 
 
 
-;// CONCATENATED MODULE: ./src/generated/index.ts
+;// CONCATENATED MODULE: ./src/public/shared/generated/index.ts
 /* tslint:disable */
 /* eslint-disable */
 
 
 
-;// 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); }
+;// CONCATENATED MODULE: ./src/public/shared/CommonTypes.ts
 /**
- * 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 modules, but also won't call these methods so won't trigger the imports.
+ * Workaround for tsc aliases, where we cannot export implementation-less modules in our dists.
  */
-var NodeUtils = /*#__PURE__*/function () {
-  function NodeUtils() {
-    NodeUtils_classCallCheck(this, NodeUtils);
+var CommonTypesNoOp = false;
+;// CONCATENATED MODULE: ./src/private/TypeUtils.ts
+function assertUnreachable(x) {
+  throw new Error("Didn't expect to get here: ".concat(JSON.stringify(x)));
+}
+function isDefinedEntry(object) {
+  return object[1] !== undefined && object[1] !== null;
+}
+;// CONCATENATED MODULE: ./src/public/shared/UrlBuilder.ts
+function UrlBuilder_typeof(obj) { "@babel/helpers - typeof"; return UrlBuilder_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; }, UrlBuilder_typeof(obj); }
+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 _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 _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 _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 _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 UrlBuilder_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function UrlBuilder_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, UrlBuilder_toPropertyKey(descriptor.key), descriptor); } }
+function UrlBuilder_createClass(Constructor, protoProps, staticProps) { if (protoProps) UrlBuilder_defineProperties(Constructor.prototype, protoProps); if (staticProps) UrlBuilder_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function UrlBuilder_toPropertyKey(arg) { var key = UrlBuilder_toPrimitive(arg, "string"); return UrlBuilder_typeof(key) === "symbol" ? key : String(key); }
+function UrlBuilder_toPrimitive(input, hint) { if (UrlBuilder_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (UrlBuilder_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+
+var UrlBuilder = /*#__PURE__*/function () {
+  function UrlBuilder(config) {
+    UrlBuilder_classCallCheck(this, UrlBuilder);
+    var _a;
+    this.cdnUrl = (_a = config === null || config === void 0 ? void 0 : config.cdnUrl) !== null && _a !== void 0 ? _a : BytescaleApiClientConfigResolver.defaultCdnUrl;
   }
-  NodeUtils_createClass(NodeUtils, null, [{
-    key: "createStream",
-    value: function createStream() {
-      try {
-        return NodeUtils_await(Promise.resolve(/* import() */).then(__lib_require__.t.bind(__lib_require__, "stream", 23)), 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;
+  /**
+   * Builds a URL to either a raw file or a transformed file.
+   *
+   * Example 1) Raw file:
+   *
+   *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg" })
+   *
+   * Example 2) Image resized to 500x500:
+   *
+   *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg", transformation: { type: "image", params: { w: 500, h: 500, fit: "crop" } } })
+   *
+   * Example 3) Image resized to 500x500, which is privately accessible (i.e. requires 'AuthManager.beginAuthSession' before it can be accessed):
+   *
+   *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg", transformation: { type: "image", params: { w: 500, h: 500, fit: "crop" } }, auth: true })
+   */
+  UrlBuilder_createClass(UrlBuilder, [{
+    key: "url",
+    value: function url(params) {
+      var _a;
+      return ((_a = params.options) === null || _a === void 0 ? void 0 : _a.transformation) === undefined ? this.raw(params) : this.transformation(params, params.options.transformation);
+    }
+  }, {
+    key: "raw",
+    value: function raw(params) {
+      var _a;
+      var baseUrl = this.getBaseUrl(params, "raw");
+      var commonParams = this.getCommonQueryParams((_a = params.options) !== null && _a !== void 0 ? _a : {});
+      return this.addQueryParams(baseUrl, commonParams);
+    }
+  }, {
+    key: "transformation",
+    value: function transformation(params, trans) {
+      var _a;
+      var baseUrl = this.getBaseUrl(params, trans.type === "preset" ? trans.preset : trans.type);
+      var transParams = this.getTransformationParams(trans, {
+        cachePermanently: "cache_perm"
+      });
+      var commonParams = this.getCommonQueryParams((_a = params.options) !== null && _a !== void 0 ? _a : {});
+      return this.addQueryParams(baseUrl, [].concat(_toConsumableArray(commonParams), _toConsumableArray(transParams)));
+    }
+  }, {
+    key: "getBaseUrl",
+    value: function getBaseUrl(params, prefix) {
+      return "".concat(this.cdnUrl, "/").concat(params.accountId, "/").concat(prefix).concat(params.filePath);
+    }
+  }, {
+    key: "getCommonQueryParams",
+    value: function getCommonQueryParams(params) {
+      return this.makeQueryParams(["auth", "cache", "cacheTtl", "version", "forceDownloadPrompt"], {
+        cacheTtl: "cache_ttl",
+        forceDownloadPrompt: "download"
+      })(params);
+    }
+  }, {
+    key: "makeQueryParams",
+    value: function makeQueryParams(keys, keyOverrides) {
+      return function (data) {
+        var result = [];
+        keys.forEach(function (key) {
+          var _a;
+          var value = data[key];
+          if (value !== undefined) {
+            result.push([(_a = keyOverrides[key]) !== null && _a !== void 0 ? _a : key, value.toString()]);
+          }
         });
-      } catch (e) {
-        return Promise.reject(e);
-      }
+        return result;
+      };
     }
   }, {
-    key: "createBlob",
-    value: function createBlob(sources, options) {
-      try {
-        return NodeUtils_await(Promise.resolve(/* import() */).then(__lib_require__.t.bind(__lib_require__, "buffer", 23)), function (_import2) {
-          var bufferModule = _import2["default"];
-          var B = bufferModule.Blob;
-          return new B(sources, options);
+    key: "getTransformationParams",
+    value: function getTransformationParams(trans, keyRewrites) {
+      if (trans.params === undefined) {
+        return [];
+      }
+      var serializeObj = function serializeObj(obj) {
+        return Object.entries(obj).filter(isDefinedEntry).map(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            key = _ref2[0],
+            value = _ref2[1];
+          var _a;
+          return [(_a = keyRewrites[key]) !== null && _a !== void 0 ? _a : key, value.toString()];
         });
-      } catch (e) {
-        return Promise.reject(e);
-      }
+      };
+      return Array.isArray(trans.params) ? trans.params.flatMap(serializeObj) : serializeObj(trans.params);
+    }
+  }, {
+    key: "addQueryParams",
+    value: function addQueryParams(baseUrl, params) {
+      if (params.length === 0) {
+        return baseUrl;
+      }
+      return "".concat(baseUrl, "?").concat(params.map(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          key = _ref4[0],
+          value = _ref4[1];
+        return "".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(value));
+      }).join("&"));
     }
   }]);
-  return NodeUtils;
+  return UrlBuilder;
 }();
-;// 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) {
+;// CONCATENATED MODULE: ./src/public/shared/UrlBuilderTypes.ts
+/**
+ * Workaround for tsc aliases, where we cannot export implementation-less modules in our dists.
+ */
+var UrlBuilderTypesNoOp = false;
+;// CONCATENATED MODULE: ./src/public/shared/index.ts
+
+
+
+
+;// CONCATENATED MODULE: ./src/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 _async(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+function _invokeIgnored(body) {
   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 result.then(UploadManagerBase_empty);
   }
-  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); }
-var CancelledError = /*#__PURE__*/function (_Error) {
-  UploadModel_inherits(CancelledError, _Error);
-  var _super = UploadModel_createSuper(CancelledError);
-  function CancelledError(msg) {
-    var _this;
-    UploadModel_classCallCheck(this, CancelledError);
-    _this = _super.call(this, msg);
-    _this.msg = msg;
-    _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 function () {
-    for (var args = [], i = 0; i < arguments.length; i++) {
-      args[i] = arguments[i];
-    }
-    try {
-      return Promise.resolve(f.apply(this, args));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-}
-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);
-  }
-}
-function _settle(pact, state, value) {
-  if (!pact.s) {
-    if (value instanceof _Pact) {
-      if (value.s) {
-        if (state & 1) {
-          state = value.s;
-        }
-        value = value.v;
-      } else {
-        value.o = _settle.bind(null, pact, state);
-        return;
+function _settle(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof _Pact) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
+        }
+        value = value.v;
+      } else {
+        value.o = _settle.bind(null, pact, state);
+        return;
       }
     }
     if (value && value.then) {
@@ -1906,16 +1656,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 _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 _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 UploadManagerBase_toConsumableArray(arr) { return UploadManagerBase_arrayWithoutHoles(arr) || UploadManagerBase_iterableToArray(arr) || UploadManagerBase_unsupportedIterableToArray(arr) || UploadManagerBase_nonIterableSpread(); }
+function UploadManagerBase_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 UploadManagerBase_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return UploadManagerBase_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 UploadManagerBase_arrayLikeToArray(o, minLen); }
+function UploadManagerBase_iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function UploadManagerBase_arrayWithoutHoles(arr) { if (Array.isArray(arr)) return UploadManagerBase_arrayLikeToArray(arr); }
+function UploadManagerBase_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;
   }
@@ -1924,46 +1680,72 @@ 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 = UploadManagerBase_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, _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) {
@@ -1971,22 +1753,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,
@@ -2004,15 +1849,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,
@@ -2031,407 +1876,766 @@ 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 = UploadManagerBase_toConsumableArray(items);
+        return _awaitIgnored(Promise.all(UploadManagerBase_toConsumableArray(Array(concurrency).keys()).map(_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);
       }
     }
-    /**
-     * Only expected to be called in Node.js environments, and as such, we can assume 'BlobLike' is not a DOM 'File' object.
-     */
-  }, {
-    key: "blobToBuffer",
-    value: function blobToBuffer(blob) {
-      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.");
-        });
-      } catch (e) {
-        return Promise.reject(e);
+  }]);
+  return UploadManagerBase;
+}();
+;// CONCATENATED MODULE: external "stream"
+var external_stream_namespaceObject = require("stream");
+;// CONCATENATED MODULE: ./src/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/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 NodeChunkedStream_slicedToArray(arr, i) { return NodeChunkedStream_arrayWithHoles(arr) || NodeChunkedStream_iterableToArrayLimit(arr, i) || NodeChunkedStream_unsupportedIterableToArray(arr, i) || NodeChunkedStream_nonIterableRest(); }
+function NodeChunkedStream_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 NodeChunkedStream_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 NodeChunkedStream_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();
       }
     }
+    /**
+     * 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: "sliceDataForRequest",
-    value: function sliceDataForRequest(data, part) {
+    key: "runChunkPipeline",
+    value: function runChunkPipeline() {
       try {
-        var _this12 = this;
-        if (part.range.inclusiveEnd === -1) {
-          return "";
-        }
-        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).
+        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 = NodeChunkedStream_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: "isNodeJs",
-    value: function isNodeJs() {
-      return typeof process !== "undefined" && process.versions !== undefined && process.versions.node !== undefined;
+    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.");
+        }
+        this.consumer = {
+          bytesRemaining: bytesToConsumeFromStream,
+          stream: readable
+        };
+        this.source.resume();
+      } else {
+        StreamUtils.endStream(readable);
+      }
+      return readable;
     }
   }, {
-    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: "consumeFromBuffer",
+    value: function consumeFromBuffer(bytes) {
+      var splitResult = this.splitBuffer(this.buffer, bytes);
+      if (splitResult === undefined) {
+        return undefined;
       }
+      var _splitResult2 = NodeChunkedStream_slicedToArray(splitResult, 2),
+        consumed = _splitResult2[0],
+        remaining = _splitResult2[1];
+      this.buffer = remaining;
+      return consumed;
     }
   }, {
-    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;
+    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];
+    }
+  }]);
+  return NodeChunkedStream;
+}();
+;// CONCATENATED MODULE: external "buffer"
+var external_buffer_namespaceObject = require("buffer");
+;// CONCATENATED MODULE: ./src/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).");
-              });
-            });
-          });
-        });
+          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: "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: "postUpload",
+    value: function postUpload(init) {
+      try {
+        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);
       }
     }
   }, {
-    key: "processUploadSource",
-    value: function processUploadSource(data) {
+    key: "doPutUploadPart",
+    value: function doPutUploadPart(part, contentLength, source, onProgress, addCancellationHandler) {
       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).");
+        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: "stringToBlob",
-    value: function stringToBlob(data) {
+    key: "coerceRequestBody",
+    value: function coerceRequestBody(data) {
+      return data; // node-fetch supports 'NodeJS.ReadableStream'
+    }
+  }, {
+    key: "sliceDataForRequest",
+    value: function sliceDataForRequest(data, part) {
       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 (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);
       }
-    } // Supported by browsers & newer versions of Node.js.
+    }
+  }]);
+  return UploadManager;
+}(UploadManagerBase);
+;// CONCATENATED MODULE: ./src/private/EnvChecker.ts
+function EnvChecker_typeof(obj) { "@babel/helpers - typeof"; return EnvChecker_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; }, EnvChecker_typeof(obj); }
+function EnvChecker_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function EnvChecker_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, EnvChecker_toPropertyKey(descriptor.key), descriptor); } }
+function EnvChecker_createClass(Constructor, protoProps, staticProps) { if (protoProps) EnvChecker_defineProperties(Constructor.prototype, protoProps); if (staticProps) EnvChecker_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function EnvChecker_toPropertyKey(arg) { var key = EnvChecker_toPrimitive(arg, "string"); return EnvChecker_typeof(key) === "symbol" ? key : String(key); }
+function EnvChecker_toPrimitive(input, hint) { if (EnvChecker_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (EnvChecker_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var EnvChecker = /*#__PURE__*/function () {
+  function EnvChecker() {
+    EnvChecker_classCallCheck(this, EnvChecker);
+  }
+  EnvChecker_createClass(EnvChecker, null, [{
+    key: "isNodeJs",
+    value: function isNodeJs() {
+      return typeof process !== "undefined" && process.versions !== undefined && process.versions.node !== undefined;
+    }
   }, {
-    key: "globalBlob",
-    value: function globalBlob(data) {
-      var B = globalThis.Blob;
-      if (B === undefined) {
-        return undefined;
+    key: "methodRequiresBrowser",
+    value: function methodRequiresBrowser(methodName) {
+      if (EnvChecker.isNodeJs()) {
+        return new Error("You must call '".concat(methodName, "' in the browser. (You are currently in Node.js.)"));
       }
-      return new B([data], {
-        type: this.stringMimeType
-      });
+      return new Error("The '".concat(methodName, "' method cannot be called because you have bundled the Node.js implementation of the Bytescale JavaScript SDK into your client-side code. Please ensure your bundling tool (Webpack, Rollup, etc.) is honouring the \"browser\" field of the \"package.json\" file for this package, as this will allow the browser implementation of the Bytescale JavaScript SDK to be included in your client-side code."));
     }
-    // Fallback for Node.js
-  }, {
-    key: "nodeJsBlob",
-    value: function nodeJsBlob(data) {
+  }]);
+  return EnvChecker;
+}();
+;// CONCATENATED MODULE: ./src/public/node/AuthManagerNode.ts
+function AuthManagerNode_typeof(obj) { "@babel/helpers - typeof"; return AuthManagerNode_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; }, AuthManagerNode_typeof(obj); }
+function AuthManagerNode_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function AuthManagerNode_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, AuthManagerNode_toPropertyKey(descriptor.key), descriptor); } }
+function AuthManagerNode_createClass(Constructor, protoProps, staticProps) { if (protoProps) AuthManagerNode_defineProperties(Constructor.prototype, protoProps); if (staticProps) AuthManagerNode_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function AuthManagerNode_toPropertyKey(arg) { var key = AuthManagerNode_toPrimitive(arg, "string"); return AuthManagerNode_typeof(key) === "symbol" ? key : String(key); }
+function AuthManagerNode_toPrimitive(input, hint) { if (AuthManagerNode_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (AuthManagerNode_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+var AuthManager = /*#__PURE__*/function () {
+  function AuthManager() {
+    AuthManagerNode_classCallCheck(this, AuthManager);
+  }
+  AuthManagerNode_createClass(AuthManager, [{
+    key: "beginAuthSession",
+    value: function beginAuthSession(_authUrl, _authHeaders) {
       try {
-        var _this22 = this;
-        return UploadManager_await(NodeUtils.createBlob([data], {
-          type: _this22.stringMimeType
-        }));
+        throw EnvChecker.methodRequiresBrowser("beginAuthSession");
       } catch (e) {
         return Promise.reject(e);
       }
     }
   }, {
-    key: "mapAsync",
-    value: function mapAsync(items, concurrency, callback) {
+    key: "endAuthSession",
+    value: function endAuthSession() {
       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));
-              }
-            });
-          }));
-        }))));
+        throw EnvChecker.methodRequiresBrowser("endAuthSession");
       } catch (e) {
         return Promise.reject(e);
       }
     }
+  }, {
+    key: "isAuthSessionActive",
+    value: function isAuthSessionActive() {
+      return false;
+    }
   }]);
-  return UploadManager;
+  return AuthManager;
 }();
-;// CONCATENATED MODULE: ./src/uploads/index.ts
+;// CONCATENATED MODULE: ./src/public/node/index.ts
 
 
-
-;// CONCATENATED MODULE: ./src/index.ts
+;// CONCATENATED MODULE: ./src/index.node.ts
 /* tslint:disable */
 /* eslint-disable */
 
 
-}();
 module.exports = __lib_exports__;
 /******/ })()
 ;