npm - @uploadcare/upload-client - Versions diffs - 3.1.0 → 4.0.0 - Mend

@uploadcare/upload-client 3.1.0 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md +5 -3
package/dist/index.browser.js +1441 -1451
package/dist/{index.js → index.node.js} +1468 -1463
package/dist/index.react-native.js +1546 -0
package/dist/types.d.ts +47 -37
package/package.json +30 -37
package/dist/index.browser.cjs +0 -1743
package/dist/index.cjs +0 -1775

package/dist/{index.js → index.node.js} RENAMED Viewed

@@ -3,1555 +3,1560 @@ import https from 'https';
 import { parse } from 'url';
 import { Transform, Readable } from 'stream';
 import NodeFormData from 'form-data';
-import { AbortController } from 'abort-controller';
-export { AbortController } from 'abort-controller';
 import WebSocket from 'ws';
-class UploadClientError extends Error {
-    constructor(message, code, request, response, headers) {
-        super();
-        this.name = 'UploadClientError';
-        this.message = message;
-        this.code = code;
-        this.request = request;
-        this.response = response;
-        this.headers = headers;
-        Object.setPrototypeOf(this, UploadClientError.prototype);
-    }
-}
-const cancelError = (message = 'Request canceled') => {
-    const error = new UploadClientError(message);
-    error.isCancel = true;
-    return error;
+class UploadClientError extends Error {
+    constructor(message, code, request, response, headers) {
+        super();
+        this.name = 'UploadClientError';
+        this.message = message;
+        this.code = code;
+        this.request = request;
+        this.response = response;
+        this.headers = headers;
+        Object.setPrototypeOf(this, UploadClientError.prototype);
+    }
+}
+const cancelError = (message = 'Request canceled') => {
+    const error = new UploadClientError(message);
+    error.isCancel = true;
+    return error;
 };
-const onCancel = (signal, callback) => {
-    if (signal) {
-        if (signal.aborted) {
-            Promise.resolve().then(callback);
-        }
-        else {
-            signal.addEventListener('abort', () => callback(), { once: true });
-        }
-    }
+const onCancel = (signal, callback) => {
+    if (signal) {
+        if (signal.aborted) {
+            Promise.resolve().then(callback);
+        }
+        else {
+            signal.addEventListener('abort', () => callback(), { once: true });
+        }
+    }
 };
-// ProgressEmitter is a simple PassThrough-style transform stream which keeps
-// track of the number of bytes which have been piped through it and will
-// invoke the `onprogress` function whenever new number are available.
-class ProgressEmitter extends Transform {
-    constructor(onProgress, size) {
-        super();
-        this._onprogress = onProgress;
-        this._position = 0;
-        this.size = size;
-    }
-    _transform(chunk, encoding, callback) {
-        this._position += chunk.length;
-        this._onprogress({
-            isComputable: true,
-            value: this._position / this.size
-        });
-        callback(null, chunk);
-    }
-}
-const getLength = (formData) => new Promise((resolve, reject) => {
-    formData.getLength((error, length) => {
-        if (error)
-            reject(error);
-        else
-            resolve(length);
-    });
-});
-function isFormData(formData) {
-    if (formData && formData.toString() === '[object FormData]') {
-        return true;
-    }
-    return false;
-}
-function isReadable(data, isFormData) {
-    if (data && (data instanceof Readable || isFormData)) {
-        return true;
-    }
-    return false;
-}
-const request = (params) => {
-    const { method = 'GET', url, data, headers = {}, signal, onProgress } = params;
-    return Promise.resolve()
-        .then(() => {
-        if (isFormData(data)) {
-            return getLength(data);
-        }
-        else {
-            return undefined;
-        }
-    })
-        .then((length) => new Promise((resolve, reject) => {
-        const isFormData = !!length;
-        let aborted = false;
-        const options = parse(url);
-        options.method = method;
-        options.headers = isFormData
-            ? Object.assign(data.getHeaders(), headers)
-            : headers;
-        if (isFormData || (data && data.length)) {
-            options.headers['Content-Length'] =
-                length || data.length;
-        }
-        const req = options.protocol !== 'https:'
-            ? http.request(options)
-            : https.request(options);
-        onCancel(signal, () => {
-            aborted = true;
-            req.abort();
-            reject(cancelError());
-        });
-        req.on('response', (res) => {
-            if (aborted)
-                return;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const resChunks = [];
-            res.on('data', (data) => {
-                resChunks.push(data);
-            });
-            res.on('end', () => resolve({
-                data: Buffer.concat(resChunks).toString('utf8'),
-                status: res.statusCode,
-                headers: res.headers,
-                request: params
-            }));
-        });
-        req.on('error', (err) => {
-            if (aborted)
-                return;
-            reject(err);
-        });
-        if (isReadable(data, isFormData)) {
-            if (onProgress && length) {
-                data.pipe(new ProgressEmitter(onProgress, length)).pipe(req);
-            }
-            else {
-                data.pipe(req);
-            }
-        }
-        else {
-            req.end(data);
-        }
-    }));
+// ProgressEmitter is a simple PassThrough-style transform stream which keeps
+// track of the number of bytes which have been piped through it and will
+// invoke the `onprogress` function whenever new number are available.
+class ProgressEmitter extends Transform {
+    constructor(onProgress, size) {
+        super();
+        this._onprogress = onProgress;
+        this._position = 0;
+        this.size = size;
+    }
+    _transform(chunk, encoding, callback) {
+        this._position += chunk.length;
+        this._onprogress({
+            isComputable: true,
+            value: this._position / this.size
+        });
+        callback(null, chunk);
+    }
+}
+const getLength = (formData) => new Promise((resolve, reject) => {
+    formData.getLength((error, length) => {
+        if (error)
+            reject(error);
+        else
+            resolve(length);
+    });
+});
+function isFormData(formData) {
+    if (formData && formData.toString() === '[object FormData]') {
+        return true;
+    }
+    return false;
+}
+function isReadable(data, isFormData) {
+    if (data && (data instanceof Readable || isFormData)) {
+        return true;
+    }
+    return false;
+}
+const request = (params) => {
+    const { method = 'GET', url, data, headers = {}, signal, onProgress } = params;
+    return Promise.resolve()
+        .then(() => {
+        if (isFormData(data)) {
+            return getLength(data);
+        }
+        else {
+            return undefined;
+        }
+    })
+        .then((length) => new Promise((resolve, reject) => {
+        const isFormData = !!length;
+        let aborted = false;
+        const options = parse(url);
+        options.method = method;
+        options.headers = isFormData
+            ? Object.assign(data.getHeaders(), headers)
+            : headers;
+        if (isFormData || (data && data.length)) {
+            options.headers['Content-Length'] =
+                length || data.length;
+        }
+        const req = options.protocol !== 'https:'
+            ? http.request(options)
+            : https.request(options);
+        onCancel(signal, () => {
+            aborted = true;
+            req.abort();
+            reject(cancelError());
+        });
+        req.on('response', (res) => {
+            if (aborted)
+                return;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const resChunks = [];
+            res.on('data', (data) => {
+                resChunks.push(data);
+            });
+            res.on('end', () => resolve({
+                data: Buffer.concat(resChunks).toString('utf8'),
+                status: res.statusCode,
+                headers: res.headers,
+                request: params
+            }));
+        });
+        req.on('error', (err) => {
+            if (aborted)
+                return;
+            reject(err);
+        });
+        if (isReadable(data, isFormData)) {
+            if (onProgress && length) {
+                data.pipe(new ProgressEmitter(onProgress, length)).pipe(req);
+            }
+            else {
+                data.pipe(req);
+            }
+        }
+        else {
+            req.end(data);
+        }
+    }));
 };
-function identity(obj) {
-    return obj;
+function identity(obj) {
+    return obj;
 }
-const transformFile = identity;
+// node form-data has another append signature
+// see docs at https://www.npmjs.com/package/formdata-node
+const getFileOptions = ({ name, contentType }) => [
+    Object.entries({
+        filename: name,
+        contentType
+    })
+        .filter(([, value]) => !!value)
+        .reduce((acc, [key, value]) => (Object.assign(Object.assign({}, acc), { [key]: value })), {})
+].filter((value) => !!value);
+const transformFile = identity;
 var getFormData = () => new NodeFormData();
-/**
- * FileData type guard.
- */
-const isFileData = (data) => {
-    return (data !== undefined &&
-        ((typeof Blob !== 'undefined' && data instanceof Blob) ||
-            (typeof File !== 'undefined' && data instanceof File) ||
-            (typeof Buffer !== 'undefined' && data instanceof Buffer)));
-};
-/**
- * Uuid type guard.
- */
-const isUuid = (data) => {
-    const UUID_REGEX = '[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}';
-    const regExp = new RegExp(UUID_REGEX);
-    return !isFileData(data) && regExp.test(data);
-};
-/**
- * Url type guard.
- *
- * @param {NodeFile | BrowserFile | Url | Uuid} data
- */
-const isUrl = (data) => {
-    const URL_REGEX = '^(?:\\w+:)?\\/\\/([^\\s\\.]+\\.\\S{2}|localhost[\\:?\\d]*)\\S*$';
-    const regExp = new RegExp(URL_REGEX);
-    return !isFileData(data) && regExp.test(data);
+/**
+ * FileData type guard.
+ */
+const isFileData = (data) => {
+    return (data !== undefined &&
+        ((typeof Blob !== 'undefined' && data instanceof Blob) ||
+            (typeof File !== 'undefined' && data instanceof File) ||
+            (typeof Buffer !== 'undefined' && data instanceof Buffer)));
+};
+/**
+ * Uuid type guard.
+ */
+const isUuid = (data) => {
+    const UUID_REGEX = '[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}';
+    const regExp = new RegExp(UUID_REGEX);
+    return !isFileData(data) && regExp.test(data);
+};
+/**
+ * Url type guard.
+ *
+ * @param {NodeFile | BrowserFile | Url | Uuid} data
+ */
+const isUrl = (data) => {
+    const URL_REGEX = '^(?:\\w+:)?\\/\\/([^\\s\\.]+\\.\\S{2}|localhost[\\:?\\d]*)\\S*$';
+    const regExp = new RegExp(URL_REGEX);
+    return !isFileData(data) && regExp.test(data);
 };
-const isSimpleValue = (value) => {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'undefined');
-};
-const isObjectValue = (value) => {
-    return !!value && typeof value === 'object' && !Array.isArray(value);
-};
-const isFileValue = (value) => !!value &&
-    typeof value === 'object' &&
-    'data' in value &&
-    isFileData(value.data);
-function collectParams(params, inputKey, inputValue) {
-    if (isFileValue(inputValue)) {
-        const name = inputValue.name;
-        const file = transformFile(inputValue.data); // lgtm [js/superfluous-trailing-arguments]
-        params.push(name ? [inputKey, file, name] : [inputKey, file]);
-    }
-    else if (isObjectValue(inputValue)) {
-        for (const [key, value] of Object.entries(inputValue)) {
-            if (typeof value !== 'undefined') {
-                params.push([`${inputKey}[${key}]`, String(value)]);
-            }
-        }
-    }
-    else if (isSimpleValue(inputValue) && inputValue) {
-        params.push([inputKey, inputValue.toString()]);
-    }
-}
-function getFormDataParams(options) {
-    const params = [];
-    for (const [key, value] of Object.entries(options)) {
-        collectParams(params, key, value);
-    }
-    return params;
-}
-function buildFormData(options) {
-    const formData = getFormData();
-    const params = getFormDataParams(options);
-    for (const param of params) {
-        formData.append(...param);
-    }
-    return formData;
+const isSimpleValue = (value) => {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'undefined');
+};
+const isObjectValue = (value) => {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+};
+const isFileValue = (value) => !!value &&
+    typeof value === 'object' &&
+    'data' in value &&
+    isFileData(value.data);
+function collectParams(params, inputKey, inputValue) {
+    if (isFileValue(inputValue)) {
+        const { name, contentType } = inputValue;
+        const file = transformFile(inputValue.data); // lgtm [js/superfluous-trailing-arguments]
+        const options = getFileOptions({ name, contentType });
+        params.push([inputKey, file, ...options]);
+    }
+    else if (isObjectValue(inputValue)) {
+        for (const [key, value] of Object.entries(inputValue)) {
+            if (typeof value !== 'undefined') {
+                params.push([`${inputKey}[${key}]`, String(value)]);
+            }
+        }
+    }
+    else if (isSimpleValue(inputValue) && inputValue) {
+        params.push([inputKey, inputValue.toString()]);
+    }
+}
+function getFormDataParams(options) {
+    const params = [];
+    for (const [key, value] of Object.entries(options)) {
+        collectParams(params, key, value);
+    }
+    return params;
+}
+function buildFormData(options) {
+    const formData = getFormData();
+    const paramsList = getFormDataParams(options);
+    for (const params of paramsList) {
+        const [key, value, ...options] = params;
+        // node form-data has another signature for append
+        formData.append(key, value, ...options);
+    }
+    return formData;
 }
-const serializePair = (key, value) => typeof value !== 'undefined' ? `${key}=${encodeURIComponent(value)}` : null;
-// TODO: generalize value transforming logic and use it here and inside `buildFormData`
-const createQuery = (query) => Object.entries(query)
-    .reduce((params, [key, value]) => {
-    let param;
-    if (typeof value === 'object' && !Array.isArray(value)) {
-        param = Object.entries(value)
-            .filter((entry) => typeof entry[1] !== 'undefined')
-            .map((entry) => serializePair(`${key}[${entry[0]}]`, String(entry[1])));
-    }
-    else if (Array.isArray(value)) {
-        param = value.map((val) => serializePair(`${key}[]`, val));
-    }
-    else {
-        param = serializePair(key, value);
-    }
-    return params.concat(param);
-}, [])
-    .filter((x) => !!x)
-    .join('&');
-const getUrl = (base, path, query) => [
-    base,
-    path,
-    query && Object.keys(query).length > 0 ? '?' : '',
-    query && createQuery(query)
-]
-    .filter(Boolean)
+const serializePair = (key, value) => typeof value !== 'undefined' ? `${key}=${encodeURIComponent(value)}` : null;
+// TODO: generalize value transforming logic and use it here and inside `buildFormData`
+const createQuery = (query) => Object.entries(query)
+    .reduce((params, [key, value]) => {
+    let param;
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        param = Object.entries(value)
+            .filter((entry) => typeof entry[1] !== 'undefined')
+            .map((entry) => serializePair(`${key}[${entry[0]}]`, String(entry[1])));
+    }
+    else if (Array.isArray(value)) {
+        param = value.map((val) => serializePair(`${key}[]`, val));
+    }
+    else {
+        param = serializePair(key, value);
+    }
+    return params.concat(param);
+}, [])
+    .filter((x) => !!x)
+    .join('&');
+const getUrl = (base, path, query) => [
+    base,
+    path,
+    query && Object.keys(query).length > 0 ? '?' : '',
+    query && createQuery(query)
+]
+    .filter(Boolean)
     .join('');
-/*
-  Settings for future support:
-  parallelDirectUploads: 10,
- */
-const defaultSettings = {
-    baseCDN: 'https://ucarecdn.com',
-    baseURL: 'https://upload.uploadcare.com',
-    maxContentLength: 50 * 1024 * 1024,
-    retryThrottledRequestMaxTimes: 1,
-    multipartMinFileSize: 25 * 1024 * 1024,
-    multipartChunkSize: 5 * 1024 * 1024,
-    multipartMinLastPartSize: 1024 * 1024,
-    maxConcurrentRequests: 4,
-    multipartMaxAttempts: 3,
-    pollingTimeoutMilliseconds: 10000,
-    pusherKey: '79ae88bd931ea68464d9'
-};
-const defaultContentType = 'application/octet-stream';
+/*
+  Settings for future support:
+  parallelDirectUploads: 10,
+ */
+const defaultSettings = {
+    baseCDN: 'https://ucarecdn.com',
+    baseURL: 'https://upload.uploadcare.com',
+    maxContentLength: 50 * 1024 * 1024,
+    retryThrottledRequestMaxTimes: 1,
+    multipartMinFileSize: 25 * 1024 * 1024,
+    multipartChunkSize: 5 * 1024 * 1024,
+    multipartMinLastPartSize: 1024 * 1024,
+    maxConcurrentRequests: 4,
+    multipartMaxAttempts: 3,
+    pollingTimeoutMilliseconds: 10000,
+    pusherKey: '79ae88bd931ea68464d9'
+};
+const defaultContentType = 'application/octet-stream';
 const defaultFilename = 'original';
-var version = '3.1.0';
+var version = '3.1.1';
-/**
- * Returns User Agent based on version and settings.
- */
-function getUserAgent({ userAgent, publicKey = '', integration = '' } = {}) {
-    const libraryName = 'UploadcareUploadClient';
-    const libraryVersion = version;
-    const languageName = 'JavaScript';
-    if (typeof userAgent === 'string') {
-        return userAgent;
-    }
-    if (typeof userAgent === 'function') {
-        return userAgent({
-            publicKey,
-            libraryName,
-            libraryVersion,
-            languageName,
-            integration
-        });
-    }
-    const mainInfo = [libraryName, libraryVersion, publicKey]
-        .filter(Boolean)
-        .join('/');
-    const additionInfo = [languageName, integration].filter(Boolean).join('; ');
-    return `${mainInfo} (${additionInfo})`;
+/**
+ * Returns User Agent based on version and settings.
+ */
+function getUserAgent({ userAgent, publicKey = '', integration = '' } = {}) {
+    const libraryName = 'UploadcareUploadClient';
+    const libraryVersion = version;
+    const languageName = 'JavaScript';
+    if (typeof userAgent === 'string') {
+        return userAgent;
+    }
+    if (typeof userAgent === 'function') {
+        return userAgent({
+            publicKey,
+            libraryName,
+            libraryVersion,
+            languageName,
+            integration
+        });
+    }
+    const mainInfo = [libraryName, libraryVersion, publicKey]
+        .filter(Boolean)
+        .join('/');
+    const additionInfo = [languageName, integration].filter(Boolean).join('; ');
+    return `${mainInfo} (${additionInfo})`;
 }
-const SEPARATOR = /\W|_/g;
-/**
- * Transforms a string to camelCased.
- */
-function camelize(text) {
-    return text
-        .split(SEPARATOR)
-        .map((word, index) => word.charAt(0)[index > 0 ? 'toUpperCase' : 'toLowerCase']() +
-        word.slice(1))
-        .join('');
-}
-/**
- * Transforms keys of an object to camelCased recursively.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function camelizeKeys(source) {
-    if (!source || typeof source !== 'object') {
-        return source;
-    }
-    return Object.keys(source).reduce((accumulator, key) => {
-        accumulator[camelize(key)] =
-            typeof source[key] === 'object' ? camelizeKeys(source[key]) : source[key];
-        return accumulator;
-    }, {});
+const SEPARATOR = /\W|_/g;
+/**
+ * Transforms a string to camelCased.
+ */
+function camelize(text) {
+    return text
+        .split(SEPARATOR)
+        .map((word, index) => word.charAt(0)[index > 0 ? 'toUpperCase' : 'toLowerCase']() +
+        word.slice(1))
+        .join('');
+}
+/**
+ * Transforms keys of an object to camelCased recursively.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function camelizeKeys(source) {
+    if (!source || typeof source !== 'object') {
+        return source;
+    }
+    return Object.keys(source).reduce((accumulator, key) => {
+        accumulator[camelize(key)] =
+            typeof source[key] === 'object' ? camelizeKeys(source[key]) : source[key];
+        return accumulator;
+    }, {});
 }
-/**
- * setTimeout as Promise.
- *
- * @param {number} ms Timeout in milliseconds.
- */
+/**
+ * setTimeout as Promise.
+ *
+ * @param {number} ms Timeout in milliseconds.
+ */
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const defaultOptions = {
-    factor: 2,
-    time: 100
-};
-function retrier(fn, options = defaultOptions) {
-    let attempts = 0;
-    function runAttempt(fn) {
-        const defaultDelayTime = Math.round(options.time * Math.pow(options.factor, attempts));
-        const retry = (ms) => delay(ms !== null && ms !== void 0 ? ms : defaultDelayTime).then(() => {
-            attempts += 1;
-            return runAttempt(fn);
-        });
-        return fn({
-            attempt: attempts,
-            retry
-        });
-    }
-    return runAttempt(fn);
+const defaultOptions = {
+    factor: 2,
+    time: 100
+};
+function retrier(fn, options = defaultOptions) {
+    let attempts = 0;
+    function runAttempt(fn) {
+        const defaultDelayTime = Math.round(options.time * Math.pow(options.factor, attempts));
+        const retry = (ms) => delay(ms !== null && ms !== void 0 ? ms : defaultDelayTime).then(() => {
+            attempts += 1;
+            return runAttempt(fn);
+        });
+        return fn({
+            attempt: attempts,
+            retry
+        });
+    }
+    return runAttempt(fn);
 }
-const REQUEST_WAS_THROTTLED_CODE = 'RequestThrottledError';
-const DEFAULT_RETRY_AFTER_TIMEOUT = 15000;
-function getTimeoutFromThrottledRequest(error) {
-    const { headers } = error || {};
-    return ((headers &&
-        Number.parseInt(headers['x-throttle-wait-seconds']) * 1000) ||
-        DEFAULT_RETRY_AFTER_TIMEOUT);
-}
-function retryIfThrottled(fn, retryThrottledMaxTimes) {
-    return retrier(({ attempt, retry }) => fn().catch((error) => {
-        if ('response' in error &&
-            (error === null || error === void 0 ? void 0 : error.code) === REQUEST_WAS_THROTTLED_CODE &&
-            attempt < retryThrottledMaxTimes) {
-            return retry(getTimeoutFromThrottledRequest(error));
-        }
-        throw error;
-    }));
+const REQUEST_WAS_THROTTLED_CODE = 'RequestThrottledError';
+const DEFAULT_RETRY_AFTER_TIMEOUT = 15000;
+function getTimeoutFromThrottledRequest(error) {
+    const { headers } = error || {};
+    return ((headers &&
+        Number.parseInt(headers['x-throttle-wait-seconds']) * 1000) ||
+        DEFAULT_RETRY_AFTER_TIMEOUT);
+}
+function retryIfThrottled(fn, retryThrottledMaxTimes) {
+    return retrier(({ attempt, retry }) => fn().catch((error) => {
+        if ('response' in error &&
+            (error === null || error === void 0 ? void 0 : error.code) === REQUEST_WAS_THROTTLED_CODE &&
+            attempt < retryThrottledMaxTimes) {
+            return retry(getTimeoutFromThrottledRequest(error));
+        }
+        throw error;
+    }));
 }
-function getStoreValue(store) {
-    return typeof store === 'undefined' ? 'auto' : store ? '1' : '0';
+function getStoreValue(store) {
+    return typeof store === 'undefined' ? 'auto' : store ? '1' : '0';
 }
-/**
- * Performs file uploading request to Uploadcare Upload API.
- * Can be canceled and has progress.
- */
-function base(file, { publicKey, fileName, baseURL = defaultSettings.baseURL, secureSignature, secureExpire, store, signal, onProgress, source = 'local', integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes, metadata }) {
-    return retryIfThrottled(() => {
-        var _a;
-        return request({
-            method: 'POST',
-            url: getUrl(baseURL, '/base/', {
-                jsonerrors: 1
-            }),
-            headers: {
-                'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
-            },
-            data: buildFormData({
-                file: {
-                    data: file,
-                    name: (_a = fileName !== null && fileName !== void 0 ? fileName : file.name) !== null && _a !== void 0 ? _a : defaultFilename
-                },
-                UPLOADCARE_PUB_KEY: publicKey,
-                UPLOADCARE_STORE: getStoreValue(store),
-                signature: secureSignature,
-                expire: secureExpire,
-                source: source,
-                metadata
-            }),
-            signal,
-            onProgress
-        }).then(({ data, headers, request }) => {
-            const response = camelizeKeys(JSON.parse(data));
-            if ('error' in response) {
-                throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
-            }
-            else {
-                return response;
-            }
-        });
-    }, retryThrottledRequestMaxTimes);
+/**
+ * Performs file uploading request to Uploadcare Upload API.
+ * Can be canceled and has progress.
+ */
+function base(file, { publicKey, fileName, contentType, baseURL = defaultSettings.baseURL, secureSignature, secureExpire, store, signal, onProgress, source = 'local', integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes, metadata }) {
+    return retryIfThrottled(() => {
+        var _a;
+        return request({
+            method: 'POST',
+            url: getUrl(baseURL, '/base/', {
+                jsonerrors: 1
+            }),
+            headers: {
+                'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
+            },
+            data: buildFormData({
+                file: {
+                    data: file,
+                    name: (_a = fileName !== null && fileName !== void 0 ? fileName : file.name) !== null && _a !== void 0 ? _a : defaultFilename,
+                    contentType
+                },
+                UPLOADCARE_PUB_KEY: publicKey,
+                UPLOADCARE_STORE: getStoreValue(store),
+                signature: secureSignature,
+                expire: secureExpire,
+                source: source,
+                metadata
+            }),
+            signal,
+            onProgress
+        }).then(({ data, headers, request }) => {
+            const response = camelizeKeys(JSON.parse(data));
+            if ('error' in response) {
+                throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
+            }
+            else {
+                return response;
+            }
+        });
+    }, retryThrottledRequestMaxTimes);
 }
-var TypeEnum;
-(function (TypeEnum) {
-    TypeEnum["Token"] = "token";
-    TypeEnum["FileInfo"] = "file_info";
-})(TypeEnum || (TypeEnum = {}));
-/**
- * Uploading files from URL.
- */
-function fromUrl(sourceUrl, { publicKey, baseURL = defaultSettings.baseURL, store, fileName, checkForUrlDuplicates, saveUrlForRecurrentUploads, secureSignature, secureExpire, source = 'url', signal, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes, metadata }) {
-    return retryIfThrottled(() => request({
-        method: 'POST',
-        headers: {
-            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
-        },
-        url: getUrl(baseURL, '/from_url/', {
-            jsonerrors: 1,
-            pub_key: publicKey,
-            source_url: sourceUrl,
-            store: getStoreValue(store),
-            filename: fileName,
-            check_URL_duplicates: checkForUrlDuplicates ? 1 : undefined,
-            save_URL_duplicates: saveUrlForRecurrentUploads ? 1 : undefined,
-            signature: secureSignature,
-            expire: secureExpire,
-            source: source,
-            metadata
-        }),
-        signal
-    }).then(({ data, headers, request }) => {
-        const response = camelizeKeys(JSON.parse(data));
-        if ('error' in response) {
-            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
-        }
-        else {
-            return response;
-        }
-    }), retryThrottledRequestMaxTimes);
+var TypeEnum;
+(function (TypeEnum) {
+    TypeEnum["Token"] = "token";
+    TypeEnum["FileInfo"] = "file_info";
+})(TypeEnum || (TypeEnum = {}));
+/**
+ * Uploading files from URL.
+ */
+function fromUrl(sourceUrl, { publicKey, baseURL = defaultSettings.baseURL, store, fileName, checkForUrlDuplicates, saveUrlForRecurrentUploads, secureSignature, secureExpire, source = 'url', signal, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes, metadata }) {
+    return retryIfThrottled(() => request({
+        method: 'POST',
+        headers: {
+            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
+        },
+        url: getUrl(baseURL, '/from_url/', {
+            jsonerrors: 1,
+            pub_key: publicKey,
+            source_url: sourceUrl,
+            store: getStoreValue(store),
+            filename: fileName,
+            check_URL_duplicates: checkForUrlDuplicates ? 1 : undefined,
+            save_URL_duplicates: saveUrlForRecurrentUploads ? 1 : undefined,
+            signature: secureSignature,
+            expire: secureExpire,
+            source: source,
+            metadata
+        }),
+        signal
+    }).then(({ data, headers, request }) => {
+        const response = camelizeKeys(JSON.parse(data));
+        if ('error' in response) {
+            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
+        }
+        else {
+            return response;
+        }
+    }), retryThrottledRequestMaxTimes);
 }
-var Status;
-(function (Status) {
-    Status["Unknown"] = "unknown";
-    Status["Waiting"] = "waiting";
-    Status["Progress"] = "progress";
-    Status["Error"] = "error";
-    Status["Success"] = "success";
-})(Status || (Status = {}));
-const isErrorResponse = (response) => {
-    return 'status' in response && response.status === Status.Error;
-};
-/**
- * Checking upload status and working with file tokens.
- */
-function fromUrlStatus(token, { publicKey, baseURL = defaultSettings.baseURL, signal, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes } = {}) {
-    return retryIfThrottled(() => request({
-        method: 'GET',
-        headers: publicKey
-            ? {
-                'X-UC-User-Agent': getUserAgent({
-                    publicKey,
-                    integration,
-                    userAgent
-                })
-            }
-            : undefined,
-        url: getUrl(baseURL, '/from_url/status/', {
-            jsonerrors: 1,
-            token
-        }),
-        signal
-    }).then(({ data, headers, request }) => {
-        const response = camelizeKeys(JSON.parse(data));
-        if ('error' in response && !isErrorResponse(response)) {
-            throw new UploadClientError(response.error.content, undefined, request, response, headers);
-        }
-        else {
-            return response;
-        }
-    }), retryThrottledRequestMaxTimes);
+var Status;
+(function (Status) {
+    Status["Unknown"] = "unknown";
+    Status["Waiting"] = "waiting";
+    Status["Progress"] = "progress";
+    Status["Error"] = "error";
+    Status["Success"] = "success";
+})(Status || (Status = {}));
+const isErrorResponse = (response) => {
+    return 'status' in response && response.status === Status.Error;
+};
+/**
+ * Checking upload status and working with file tokens.
+ */
+function fromUrlStatus(token, { publicKey, baseURL = defaultSettings.baseURL, signal, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes } = {}) {
+    return retryIfThrottled(() => request({
+        method: 'GET',
+        headers: publicKey
+            ? {
+                'X-UC-User-Agent': getUserAgent({
+                    publicKey,
+                    integration,
+                    userAgent
+                })
+            }
+            : undefined,
+        url: getUrl(baseURL, '/from_url/status/', {
+            jsonerrors: 1,
+            token
+        }),
+        signal
+    }).then(({ data, headers, request }) => {
+        const response = camelizeKeys(JSON.parse(data));
+        if ('error' in response && !isErrorResponse(response)) {
+            throw new UploadClientError(response.error.content, undefined, request, response, headers);
+        }
+        else {
+            return response;
+        }
+    }), retryThrottledRequestMaxTimes);
 }
-/**
- * Create files group.
- */
-function group(uuids, { publicKey, baseURL = defaultSettings.baseURL, jsonpCallback, secureSignature, secureExpire, signal, source, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes }) {
-    return retryIfThrottled(() => request({
-        method: 'POST',
-        headers: {
-            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
-        },
-        url: getUrl(baseURL, '/group/', {
-            jsonerrors: 1,
-            pub_key: publicKey,
-            files: uuids,
-            callback: jsonpCallback,
-            signature: secureSignature,
-            expire: secureExpire,
-            source
-        }),
-        signal
-    }).then(({ data, headers, request }) => {
-        const response = camelizeKeys(JSON.parse(data));
-        if ('error' in response) {
-            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
-        }
-        else {
-            return response;
-        }
-    }), retryThrottledRequestMaxTimes);
+/**
+ * Create files group.
+ */
+function group(uuids, { publicKey, baseURL = defaultSettings.baseURL, jsonpCallback, secureSignature, secureExpire, signal, source, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes }) {
+    return retryIfThrottled(() => request({
+        method: 'POST',
+        headers: {
+            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
+        },
+        url: getUrl(baseURL, '/group/', {
+            jsonerrors: 1,
+            pub_key: publicKey,
+            files: uuids,
+            callback: jsonpCallback,
+            signature: secureSignature,
+            expire: secureExpire,
+            source
+        }),
+        signal
+    }).then(({ data, headers, request }) => {
+        const response = camelizeKeys(JSON.parse(data));
+        if ('error' in response) {
+            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
+        }
+        else {
+            return response;
+        }
+    }), retryThrottledRequestMaxTimes);
 }
-/**
- * Get info about group.
- */
-function groupInfo(id, { publicKey, baseURL = defaultSettings.baseURL, signal, source, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes }) {
-    return retryIfThrottled(() => request({
-        method: 'GET',
-        headers: {
-            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
-        },
-        url: getUrl(baseURL, '/group/info/', {
-            jsonerrors: 1,
-            pub_key: publicKey,
-            group_id: id,
-            source
-        }),
-        signal
-    }).then(({ data, headers, request }) => {
-        const response = camelizeKeys(JSON.parse(data));
-        if ('error' in response) {
-            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
-        }
-        else {
-            return response;
-        }
-    }), retryThrottledRequestMaxTimes);
+/**
+ * Get info about group.
+ */
+function groupInfo(id, { publicKey, baseURL = defaultSettings.baseURL, signal, source, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes }) {
+    return retryIfThrottled(() => request({
+        method: 'GET',
+        headers: {
+            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
+        },
+        url: getUrl(baseURL, '/group/info/', {
+            jsonerrors: 1,
+            pub_key: publicKey,
+            group_id: id,
+            source
+        }),
+        signal
+    }).then(({ data, headers, request }) => {
+        const response = camelizeKeys(JSON.parse(data));
+        if ('error' in response) {
+            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
+        }
+        else {
+            return response;
+        }
+    }), retryThrottledRequestMaxTimes);
 }
-/**
- * Returns a JSON dictionary holding file info.
- */
-function info(uuid, { publicKey, baseURL = defaultSettings.baseURL, signal, source, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes }) {
-    return retryIfThrottled(() => request({
-        method: 'GET',
-        headers: {
-            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
-        },
-        url: getUrl(baseURL, '/info/', {
-            jsonerrors: 1,
-            pub_key: publicKey,
-            file_id: uuid,
-            source
-        }),
-        signal
-    }).then(({ data, headers, request }) => {
-        const response = camelizeKeys(JSON.parse(data));
-        if ('error' in response) {
-            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
-        }
-        else {
-            return response;
-        }
-    }), retryThrottledRequestMaxTimes);
+/**
+ * Returns a JSON dictionary holding file info.
+ */
+function info(uuid, { publicKey, baseURL = defaultSettings.baseURL, signal, source, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes }) {
+    return retryIfThrottled(() => request({
+        method: 'GET',
+        headers: {
+            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
+        },
+        url: getUrl(baseURL, '/info/', {
+            jsonerrors: 1,
+            pub_key: publicKey,
+            file_id: uuid,
+            source
+        }),
+        signal
+    }).then(({ data, headers, request }) => {
+        const response = camelizeKeys(JSON.parse(data));
+        if ('error' in response) {
+            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
+        }
+        else {
+            return response;
+        }
+    }), retryThrottledRequestMaxTimes);
 }
-/**
- * Start multipart uploading.
- */
-function multipartStart(size, { publicKey, contentType, fileName, multipartChunkSize = defaultSettings.multipartChunkSize, baseURL = '', secureSignature, secureExpire, store, signal, source = 'local', integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes, metadata }) {
-    return retryIfThrottled(() => request({
-        method: 'POST',
-        url: getUrl(baseURL, '/multipart/start/', { jsonerrors: 1 }),
-        headers: {
-            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
-        },
-        data: buildFormData({
-            filename: fileName !== null && fileName !== void 0 ? fileName : defaultFilename,
-            size: size,
-            content_type: contentType !== null && contentType !== void 0 ? contentType : defaultContentType,
-            part_size: multipartChunkSize,
-            UPLOADCARE_STORE: getStoreValue(store),
-            UPLOADCARE_PUB_KEY: publicKey,
-            signature: secureSignature,
-            expire: secureExpire,
-            source: source,
-            metadata
-        }),
-        signal
-    }).then(({ data, headers, request }) => {
-        const response = camelizeKeys(JSON.parse(data));
-        if ('error' in response) {
-            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
-        }
-        else {
-            // convert to array
-            response.parts = Object.keys(response.parts).map((key) => response.parts[key]);
-            return response;
-        }
-    }), retryThrottledRequestMaxTimes);
+/**
+ * Start multipart uploading.
+ */
+function multipartStart(size, { publicKey, contentType, fileName, multipartChunkSize = defaultSettings.multipartChunkSize, baseURL = '', secureSignature, secureExpire, store, signal, source = 'local', integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes, metadata }) {
+    return retryIfThrottled(() => request({
+        method: 'POST',
+        url: getUrl(baseURL, '/multipart/start/', { jsonerrors: 1 }),
+        headers: {
+            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
+        },
+        data: buildFormData({
+            filename: fileName !== null && fileName !== void 0 ? fileName : defaultFilename,
+            size: size,
+            content_type: contentType !== null && contentType !== void 0 ? contentType : defaultContentType,
+            part_size: multipartChunkSize,
+            UPLOADCARE_STORE: getStoreValue(store),
+            UPLOADCARE_PUB_KEY: publicKey,
+            signature: secureSignature,
+            expire: secureExpire,
+            source: source,
+            metadata
+        }),
+        signal
+    }).then(({ data, headers, request }) => {
+        const response = camelizeKeys(JSON.parse(data));
+        if ('error' in response) {
+            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
+        }
+        else {
+            // convert to array
+            response.parts = Object.keys(response.parts).map((key) => response.parts[key]);
+            return response;
+        }
+    }), retryThrottledRequestMaxTimes);
 }
-/**
- * Complete multipart uploading.
- */
-function multipartUpload(part, url, { signal, onProgress }) {
-    return request({
-        method: 'PUT',
-        url,
-        data: part,
-        // Upload request can't be non-computable because we always know exact size
-        onProgress: onProgress,
-        signal
-    })
-        .then((result) => {
-        // hack for node ¯\_(ツ)_/¯
-        if (onProgress)
-            onProgress({
-                isComputable: true,
-                value: 1
-            });
-        return result;
-    })
-        .then(({ status }) => ({ code: status }));
+/**
+ * Complete multipart uploading.
+ */
+function multipartUpload(part, url, { signal, onProgress }) {
+    return request({
+        method: 'PUT',
+        url,
+        data: part,
+        // Upload request can't be non-computable because we always know exact size
+        onProgress: onProgress,
+        signal
+    })
+        .then((result) => {
+        // hack for node ¯\_(ツ)_/¯
+        if (onProgress)
+            onProgress({
+                isComputable: true,
+                value: 1
+            });
+        return result;
+    })
+        .then(({ status }) => ({ code: status }));
 }
-/**
- * Complete multipart uploading.
- */
-function multipartComplete(uuid, { publicKey, baseURL = defaultSettings.baseURL, source = 'local', signal, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes }) {
-    return retryIfThrottled(() => request({
-        method: 'POST',
-        url: getUrl(baseURL, '/multipart/complete/', { jsonerrors: 1 }),
-        headers: {
-            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
-        },
-        data: buildFormData({
-            uuid: uuid,
-            UPLOADCARE_PUB_KEY: publicKey,
-            source: source
-        }),
-        signal
-    }).then(({ data, headers, request }) => {
-        const response = camelizeKeys(JSON.parse(data));
-        if ('error' in response) {
-            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
-        }
-        else {
-            return response;
-        }
-    }), retryThrottledRequestMaxTimes);
+/**
+ * Complete multipart uploading.
+ */
+function multipartComplete(uuid, { publicKey, baseURL = defaultSettings.baseURL, source = 'local', signal, integration, userAgent, retryThrottledRequestMaxTimes = defaultSettings.retryThrottledRequestMaxTimes }) {
+    return retryIfThrottled(() => request({
+        method: 'POST',
+        url: getUrl(baseURL, '/multipart/complete/', { jsonerrors: 1 }),
+        headers: {
+            'X-UC-User-Agent': getUserAgent({ publicKey, integration, userAgent })
+        },
+        data: buildFormData({
+            uuid: uuid,
+            UPLOADCARE_PUB_KEY: publicKey,
+            source: source
+        }),
+        signal
+    }).then(({ data, headers, request }) => {
+        const response = camelizeKeys(JSON.parse(data));
+        if ('error' in response) {
+            throw new UploadClientError(response.error.content, response.error.errorCode, request, response, headers);
+        }
+        else {
+            return response;
+        }
+    }), retryThrottledRequestMaxTimes);
 }
-class UploadcareFile {
-    constructor(fileInfo, { baseCDN, defaultEffects, fileName }) {
-        this.name = null;
-        this.size = null;
-        this.isStored = null;
-        this.isImage = null;
-        this.mimeType = null;
-        this.cdnUrl = null;
-        this.cdnUrlModifiers = null;
-        this.originalUrl = null;
-        this.originalFilename = null;
-        this.imageInfo = null;
-        this.videoInfo = null;
-        this.contentInfo = null;
-        this.metadata = null;
-        const { uuid, s3Bucket } = fileInfo;
-        const urlBase = s3Bucket
-            ? `https://${s3Bucket}.s3.amazonaws.com/${uuid}/${fileInfo.filename}`
-            : `${baseCDN}/${uuid}/`;
-        const cdnUrlModifiers = defaultEffects ? `-/${defaultEffects}` : null;
-        const cdnUrl = `${urlBase}${cdnUrlModifiers || ''}`;
-        const originalUrl = uuid ? urlBase : null;
-        this.uuid = uuid;
-        this.name = fileName || fileInfo.filename;
-        this.size = fileInfo.size;
-        this.isStored = fileInfo.isStored;
-        this.isImage = fileInfo.isImage;
-        this.mimeType = fileInfo.mimeType;
-        this.cdnUrl = cdnUrl;
-        this.cdnUrlModifiers = cdnUrlModifiers;
-        this.originalUrl = originalUrl;
-        this.originalFilename = fileInfo.originalFilename;
-        this.imageInfo = camelizeKeys(fileInfo.imageInfo);
-        this.videoInfo = camelizeKeys(fileInfo.videoInfo);
-        this.contentInfo = camelizeKeys(fileInfo.contentInfo);
-        this.metadata = fileInfo.metadata || null;
-    }
+class UploadcareFile {
+    constructor(fileInfo, { baseCDN, fileName }) {
+        this.name = null;
+        this.size = null;
+        this.isStored = null;
+        this.isImage = null;
+        this.mimeType = null;
+        this.cdnUrl = null;
+        this.s3Url = null;
+        this.originalFilename = null;
+        this.imageInfo = null;
+        this.videoInfo = null;
+        this.contentInfo = null;
+        this.metadata = null;
+        this.s3Bucket = null;
+        const { uuid, s3Bucket } = fileInfo;
+        const cdnUrl = `${baseCDN}/${uuid}/`;
+        const s3Url = s3Bucket
+            ? `https://${s3Bucket}.s3.amazonaws.com/${uuid}/${fileInfo.filename}`
+            : null;
+        this.uuid = uuid;
+        this.name = fileName || fileInfo.filename;
+        this.size = fileInfo.size;
+        this.isStored = fileInfo.isStored;
+        this.isImage = fileInfo.isImage;
+        this.mimeType = fileInfo.mimeType;
+        this.cdnUrl = cdnUrl;
+        this.originalFilename = fileInfo.originalFilename;
+        this.imageInfo = camelizeKeys(fileInfo.imageInfo);
+        this.videoInfo = camelizeKeys(fileInfo.videoInfo);
+        this.contentInfo = camelizeKeys(fileInfo.contentInfo);
+        this.metadata = fileInfo.metadata || null;
+        this.s3Bucket = s3Bucket || null;
+        this.s3Url = s3Url;
+    }
 }
-const DEFAULT_INTERVAL = 500;
-const poll = ({ check, interval = DEFAULT_INTERVAL, signal }) => new Promise((resolve, reject) => {
-    let timeoutId;
-    onCancel(signal, () => {
-        timeoutId && clearTimeout(timeoutId);
-        reject(cancelError('Poll cancelled'));
-    });
-    const tick = () => {
-        try {
-            Promise.resolve(check(signal))
-                .then((result) => {
-                if (result) {
-                    resolve(result);
-                }
-                else {
-                    timeoutId = setTimeout(tick, interval);
-                }
-            })
-                .catch((error) => reject(error));
-        }
-        catch (error) {
-            reject(error);
-        }
-    };
-    timeoutId = setTimeout(tick, 0);
+const DEFAULT_INTERVAL = 500;
+const poll = ({ check, interval = DEFAULT_INTERVAL, signal }) => new Promise((resolve, reject) => {
+    let timeoutId;
+    onCancel(signal, () => {
+        timeoutId && clearTimeout(timeoutId);
+        reject(cancelError('Poll cancelled'));
+    });
+    const tick = () => {
+        try {
+            Promise.resolve(check(signal))
+                .then((result) => {
+                if (result) {
+                    resolve(result);
+                }
+                else {
+                    timeoutId = setTimeout(tick, interval);
+                }
+            })
+                .catch((error) => reject(error));
+        }
+        catch (error) {
+            reject(error);
+        }
+    };
+    timeoutId = setTimeout(tick, 0);
 });
-function isReadyPoll({ file, publicKey, baseURL, source, integration, userAgent, retryThrottledRequestMaxTimes, signal, onProgress }) {
-    return poll({
-        check: (signal) => info(file, {
-            publicKey,
-            baseURL,
-            signal,
-            source,
-            integration,
-            userAgent,
-            retryThrottledRequestMaxTimes
-        }).then((response) => {
-            if (response.isReady) {
-                return response;
-            }
-            onProgress && onProgress({ isComputable: true, value: 1 });
-            return false;
-        }),
-        signal
-    });
+function isReadyPoll({ file, publicKey, baseURL, source, integration, userAgent, retryThrottledRequestMaxTimes, signal, onProgress }) {
+    return poll({
+        check: (signal) => info(file, {
+            publicKey,
+            baseURL,
+            signal,
+            source,
+            integration,
+            userAgent,
+            retryThrottledRequestMaxTimes
+        }).then((response) => {
+            if (response.isReady) {
+                return response;
+            }
+            onProgress && onProgress({ isComputable: true, value: 1 });
+            return false;
+        }),
+        signal
+    });
 }
-const uploadFromObject = (file, { publicKey, fileName, baseURL, secureSignature, secureExpire, store, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, baseCDN, metadata }) => {
-    return base(file, {
-        publicKey,
-        fileName,
-        baseURL,
-        secureSignature,
-        secureExpire,
-        store,
-        signal,
-        onProgress,
-        source,
-        integration,
-        userAgent,
-        retryThrottledRequestMaxTimes,
-        metadata
-    })
-        .then(({ file }) => {
-        return isReadyPoll({
-            file,
-            publicKey,
-            baseURL,
-            source,
-            integration,
-            userAgent,
-            retryThrottledRequestMaxTimes,
-            onProgress,
-            signal
-        });
-    })
-        .then((fileInfo) => new UploadcareFile(fileInfo, { baseCDN }));
+const uploadDirect = (file, { publicKey, fileName, baseURL, secureSignature, secureExpire, store, contentType, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, baseCDN, metadata }) => {
+    return base(file, {
+        publicKey,
+        fileName,
+        contentType,
+        baseURL,
+        secureSignature,
+        secureExpire,
+        store,
+        signal,
+        onProgress,
+        source,
+        integration,
+        userAgent,
+        retryThrottledRequestMaxTimes,
+        metadata
+    })
+        .then(({ file }) => {
+        return isReadyPoll({
+            file,
+            publicKey,
+            baseURL,
+            source,
+            integration,
+            userAgent,
+            retryThrottledRequestMaxTimes,
+            onProgress,
+            signal
+        });
+    })
+        .then((fileInfo) => new UploadcareFile(fileInfo, { baseCDN }));
 };
-const race = (fns, { signal } = {}) => {
-    let lastError = null;
-    let winnerIndex = null;
-    const controllers = fns.map(() => new AbortController());
-    const createStopRaceCallback = (i) => () => {
-        winnerIndex = i;
-        controllers.forEach((controller, index) => index !== i && controller.abort());
-    };
-    onCancel(signal, () => {
-        controllers.forEach((controller) => controller.abort());
-    });
-    return Promise.all(fns.map((fn, i) => {
-        const stopRace = createStopRaceCallback(i);
-        return Promise.resolve()
-            .then(() => fn({ stopRace, signal: controllers[i].signal }))
-            .then((result) => {
-            stopRace();
-            return result;
-        })
-            .catch((error) => {
-            lastError = error;
-            return null;
-        });
-    })).then((results) => {
-        if (winnerIndex === null) {
-            throw lastError;
-        }
-        else {
-            return results[winnerIndex];
-        }
-    });
+const race = (fns, { signal } = {}) => {
+    let lastError = null;
+    let winnerIndex = null;
+    const controllers = fns.map(() => new AbortController());
+    const createStopRaceCallback = (i) => () => {
+        winnerIndex = i;
+        controllers.forEach((controller, index) => index !== i && controller.abort());
+    };
+    onCancel(signal, () => {
+        controllers.forEach((controller) => controller.abort());
+    });
+    return Promise.all(fns.map((fn, i) => {
+        const stopRace = createStopRaceCallback(i);
+        return Promise.resolve()
+            .then(() => fn({ stopRace, signal: controllers[i].signal }))
+            .then((result) => {
+            stopRace();
+            return result;
+        })
+            .catch((error) => {
+            lastError = error;
+            return null;
+        });
+    })).then((results) => {
+        if (winnerIndex === null) {
+            throw lastError;
+        }
+        else {
+            return results[winnerIndex];
+        }
+    });
 };
-class Events {
-    constructor() {
-        this.events = Object.create({});
-    }
-    emit(event, data) {
-        var _a;
-        (_a = this.events[event]) === null || _a === void 0 ? void 0 : _a.forEach((fn) => fn(data));
-    }
-    on(event, callback) {
-        this.events[event] = this.events[event] || [];
-        this.events[event].push(callback);
-    }
-    off(event, callback) {
-        if (callback) {
-            this.events[event] = this.events[event].filter((fn) => fn !== callback);
-        }
-        else {
-            this.events[event] = [];
-        }
-    }
+class Events {
+    constructor() {
+        this.events = Object.create({});
+    }
+    emit(event, data) {
+        var _a;
+        (_a = this.events[event]) === null || _a === void 0 ? void 0 : _a.forEach((fn) => fn(data));
+    }
+    on(event, callback) {
+        this.events[event] = this.events[event] || [];
+        this.events[event].push(callback);
+    }
+    off(event, callback) {
+        if (callback) {
+            this.events[event] = this.events[event].filter((fn) => fn !== callback);
+        }
+        else {
+            this.events[event] = [];
+        }
+    }
 }
-const response = (type, data) => {
-    if (type === 'success') {
-        return Object.assign({ status: Status.Success }, data);
-    }
-    if (type === 'progress') {
-        return Object.assign({ status: Status.Progress }, data);
-    }
-    return Object.assign({ status: Status.Error }, data);
-};
-class Pusher {
-    constructor(pusherKey, disconnectTime = 30000) {
-        this.ws = undefined;
-        this.queue = [];
-        this.isConnected = false;
-        this.subscribers = 0;
-        this.emmitter = new Events();
-        this.disconnectTimeoutId = null;
-        this.key = pusherKey;
-        this.disconnectTime = disconnectTime;
-    }
-    connect() {
-        this.disconnectTimeoutId && clearTimeout(this.disconnectTimeoutId);
-        if (!this.isConnected && !this.ws) {
-            const pusherUrl = `wss://ws.pusherapp.com/app/${this.key}?protocol=5&client=js&version=1.12.2`;
-            this.ws = new WebSocket(pusherUrl);
-            this.ws.addEventListener('error', (error) => {
-                this.emmitter.emit('error', new Error(error.message));
-            });
-            this.emmitter.on('connected', () => {
-                this.isConnected = true;
-                this.queue.forEach((message) => this.send(message.event, message.data));
-                this.queue = [];
-            });
-            this.ws.addEventListener('message', (e) => {
-                const data = JSON.parse(e.data.toString());
-                switch (data.event) {
-                    case 'pusher:connection_established': {
-                        this.emmitter.emit('connected', undefined);
-                        break;
-                    }
-                    case 'pusher:ping': {
-                        this.send('pusher:pong', {});
-                        break;
-                    }
-                    case 'progress':
-                    case 'success':
-                    case 'fail': {
-                        this.emmitter.emit(data.channel, response(data.event, JSON.parse(data.data)));
-                    }
-                }
-            });
-        }
-    }
-    disconnect() {
-        const actualDisconect = () => {
-            var _a;
-            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
-            this.ws = undefined;
-            this.isConnected = false;
-        };
-        if (this.disconnectTime) {
-            this.disconnectTimeoutId = setTimeout(() => {
-                actualDisconect();
-            }, this.disconnectTime);
-        }
-        else {
-            actualDisconect();
-        }
-    }
-    send(event, data) {
-        var _a;
-        const str = JSON.stringify({ event, data });
-        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(str);
-    }
-    subscribe(token, handler) {
-        this.subscribers += 1;
-        this.connect();
-        const channel = `task-status-${token}`;
-        const message = {
-            event: 'pusher:subscribe',
-            data: { channel }
-        };
-        this.emmitter.on(channel, handler);
-        if (this.isConnected) {
-            this.send(message.event, message.data);
-        }
-        else {
-            this.queue.push(message);
-        }
-    }
-    unsubscribe(token) {
-        this.subscribers -= 1;
-        const channel = `task-status-${token}`;
-        const message = {
-            event: 'pusher:unsubscribe',
-            data: { channel }
-        };
-        this.emmitter.off(channel);
-        if (this.isConnected) {
-            this.send(message.event, message.data);
-        }
-        else {
-            this.queue = this.queue.filter((msg) => msg.data.channel !== channel);
-        }
-        if (this.subscribers === 0) {
-            this.disconnect();
-        }
-    }
-    onError(callback) {
-        this.emmitter.on('error', callback);
-        return () => this.emmitter.off('error', callback);
-    }
-}
-let pusher = null;
-const getPusher = (key) => {
-    if (!pusher) {
-        // no timeout for nodeJS and 30000 ms for browser
-        const disconectTimeout = typeof window === 'undefined' ? 0 : 30000;
-        pusher = new Pusher(key, disconectTimeout);
-    }
-    return pusher;
-};
-const preconnect = (key) => {
-    getPusher(key).connect();
+const response = (type, data) => {
+    if (type === 'success') {
+        return Object.assign({ status: Status.Success }, data);
+    }
+    if (type === 'progress') {
+        return Object.assign({ status: Status.Progress }, data);
+    }
+    return Object.assign({ status: Status.Error }, data);
+};
+class Pusher {
+    constructor(pusherKey, disconnectTime = 30000) {
+        this.ws = undefined;
+        this.queue = [];
+        this.isConnected = false;
+        this.subscribers = 0;
+        this.emmitter = new Events();
+        this.disconnectTimeoutId = null;
+        this.key = pusherKey;
+        this.disconnectTime = disconnectTime;
+    }
+    connect() {
+        this.disconnectTimeoutId && clearTimeout(this.disconnectTimeoutId);
+        if (!this.isConnected && !this.ws) {
+            const pusherUrl = `wss://ws.pusherapp.com/app/${this.key}?protocol=5&client=js&version=1.12.2`;
+            this.ws = new WebSocket(pusherUrl);
+            this.ws.addEventListener('error', (error) => {
+                this.emmitter.emit('error', new Error(error.message));
+            });
+            this.emmitter.on('connected', () => {
+                this.isConnected = true;
+                this.queue.forEach((message) => this.send(message.event, message.data));
+                this.queue = [];
+            });
+            this.ws.addEventListener('message', (e) => {
+                const data = JSON.parse(e.data.toString());
+                switch (data.event) {
+                    case 'pusher:connection_established': {
+                        this.emmitter.emit('connected', undefined);
+                        break;
+                    }
+                    case 'pusher:ping': {
+                        this.send('pusher:pong', {});
+                        break;
+                    }
+                    case 'progress':
+                    case 'success':
+                    case 'fail': {
+                        this.emmitter.emit(data.channel, response(data.event, JSON.parse(data.data)));
+                    }
+                }
+            });
+        }
+    }
+    disconnect() {
+        const actualDisconect = () => {
+            var _a;
+            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
+            this.ws = undefined;
+            this.isConnected = false;
+        };
+        if (this.disconnectTime) {
+            this.disconnectTimeoutId = setTimeout(() => {
+                actualDisconect();
+            }, this.disconnectTime);
+        }
+        else {
+            actualDisconect();
+        }
+    }
+    send(event, data) {
+        var _a;
+        const str = JSON.stringify({ event, data });
+        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(str);
+    }
+    subscribe(token, handler) {
+        this.subscribers += 1;
+        this.connect();
+        const channel = `task-status-${token}`;
+        const message = {
+            event: 'pusher:subscribe',
+            data: { channel }
+        };
+        this.emmitter.on(channel, handler);
+        if (this.isConnected) {
+            this.send(message.event, message.data);
+        }
+        else {
+            this.queue.push(message);
+        }
+    }
+    unsubscribe(token) {
+        this.subscribers -= 1;
+        const channel = `task-status-${token}`;
+        const message = {
+            event: 'pusher:unsubscribe',
+            data: { channel }
+        };
+        this.emmitter.off(channel);
+        if (this.isConnected) {
+            this.send(message.event, message.data);
+        }
+        else {
+            this.queue = this.queue.filter((msg) => msg.data.channel !== channel);
+        }
+        if (this.subscribers === 0) {
+            this.disconnect();
+        }
+    }
+    onError(callback) {
+        this.emmitter.on('error', callback);
+        return () => this.emmitter.off('error', callback);
+    }
+}
+let pusher = null;
+const getPusher = (key) => {
+    if (!pusher) {
+        // no timeout for nodeJS and 30000 ms for browser
+        const disconectTimeout = typeof window === 'undefined' ? 0 : 30000;
+        pusher = new Pusher(key, disconectTimeout);
+    }
+    return pusher;
+};
+const preconnect = (key) => {
+    getPusher(key).connect();
 };
-function pollStrategy({ token, publicKey, baseURL, integration, userAgent, retryThrottledRequestMaxTimes, onProgress, signal }) {
-    return poll({
-        check: (signal) => fromUrlStatus(token, {
-            publicKey,
-            baseURL,
-            integration,
-            userAgent,
-            retryThrottledRequestMaxTimes,
-            signal
-        }).then((response) => {
-            switch (response.status) {
-                case Status.Error: {
-                    return new UploadClientError(response.error, response.errorCode);
-                }
-                case Status.Waiting: {
-                    return false;
-                }
-                case Status.Unknown: {
-                    return new UploadClientError(`Token "${token}" was not found.`);
-                }
-                case Status.Progress: {
-                    if (onProgress) {
-                        if (response.total === 'unknown') {
-                            onProgress({ isComputable: false });
-                        }
-                        else {
-                            onProgress({
-                                isComputable: true,
-                                value: response.done / response.total
-                            });
-                        }
-                    }
-                    return false;
-                }
-                case Status.Success: {
-                    if (onProgress)
-                        onProgress({
-                            isComputable: true,
-                            value: response.done / response.total
-                        });
-                    return response;
-                }
-                default: {
-                    throw new Error('Unknown status');
-                }
-            }
-        }),
-        signal
-    });
-}
-const pushStrategy = ({ token, pusherKey, signal, onProgress }) => new Promise((resolve, reject) => {
-    const pusher = getPusher(pusherKey);
-    const unsubErrorHandler = pusher.onError(reject);
-    const destroy = () => {
-        unsubErrorHandler();
-        pusher.unsubscribe(token);
-    };
-    onCancel(signal, () => {
-        destroy();
-        reject(cancelError('pusher cancelled'));
-    });
-    pusher.subscribe(token, (result) => {
-        switch (result.status) {
-            case Status.Progress: {
-                if (onProgress) {
-                    if (result.total === 'unknown') {
-                        onProgress({ isComputable: false });
-                    }
-                    else {
-                        onProgress({
-                            isComputable: true,
-                            value: result.done / result.total
-                        });
-                    }
-                }
-                break;
-            }
-            case Status.Success: {
-                destroy();
-                if (onProgress)
-                    onProgress({
-                        isComputable: true,
-                        value: result.done / result.total
-                    });
-                resolve(result);
-                break;
-            }
-            case Status.Error: {
-                destroy();
-                reject(new UploadClientError(result.msg, result.error_code));
-            }
-        }
-    });
-});
-const uploadFromUrl = (sourceUrl, { publicKey, fileName, baseURL, baseCDN, checkForUrlDuplicates, saveUrlForRecurrentUploads, secureSignature, secureExpire, store, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, pusherKey = defaultSettings.pusherKey, metadata }) => Promise.resolve(preconnect(pusherKey))
-    .then(() => fromUrl(sourceUrl, {
-    publicKey,
-    fileName,
-    baseURL,
-    checkForUrlDuplicates,
-    saveUrlForRecurrentUploads,
-    secureSignature,
-    secureExpire,
-    store,
-    signal,
-    source,
-    integration,
-    userAgent,
-    retryThrottledRequestMaxTimes,
-    metadata
-}))
-    .catch((error) => {
-    const pusher = getPusher(pusherKey);
-    pusher === null || pusher === void 0 ? void 0 : pusher.disconnect();
-    return Promise.reject(error);
-})
-    .then((urlResponse) => {
-    if (urlResponse.type === TypeEnum.FileInfo) {
-        return urlResponse;
-    }
-    else {
-        return race([
-            ({ signal }) => pollStrategy({
-                token: urlResponse.token,
-                publicKey,
-                baseURL,
-                integration,
-                userAgent,
-                retryThrottledRequestMaxTimes,
-                onProgress,
-                signal
-            }),
-            ({ signal }) => pushStrategy({
-                token: urlResponse.token,
-                pusherKey,
-                signal,
-                onProgress
-            })
-        ], { signal });
-    }
-})
-    .then((result) => {
-    if (result instanceof UploadClientError)
-        throw result;
-    return result;
-})
-    .then((result) => isReadyPoll({
-    file: result.uuid,
-    publicKey,
-    baseURL,
-    integration,
-    userAgent,
-    retryThrottledRequestMaxTimes,
-    onProgress,
-    signal
-}))
+function pollStrategy({ token, publicKey, baseURL, integration, userAgent, retryThrottledRequestMaxTimes, onProgress, signal }) {
+    return poll({
+        check: (signal) => fromUrlStatus(token, {
+            publicKey,
+            baseURL,
+            integration,
+            userAgent,
+            retryThrottledRequestMaxTimes,
+            signal
+        }).then((response) => {
+            switch (response.status) {
+                case Status.Error: {
+                    return new UploadClientError(response.error, response.errorCode);
+                }
+                case Status.Waiting: {
+                    return false;
+                }
+                case Status.Unknown: {
+                    return new UploadClientError(`Token "${token}" was not found.`);
+                }
+                case Status.Progress: {
+                    if (onProgress) {
+                        if (response.total === 'unknown') {
+                            onProgress({ isComputable: false });
+                        }
+                        else {
+                            onProgress({
+                                isComputable: true,
+                                value: response.done / response.total
+                            });
+                        }
+                    }
+                    return false;
+                }
+                case Status.Success: {
+                    if (onProgress)
+                        onProgress({
+                            isComputable: true,
+                            value: response.done / response.total
+                        });
+                    return response;
+                }
+                default: {
+                    throw new Error('Unknown status');
+                }
+            }
+        }),
+        signal
+    });
+}
+const pushStrategy = ({ token, pusherKey, signal, onProgress }) => new Promise((resolve, reject) => {
+    const pusher = getPusher(pusherKey);
+    const unsubErrorHandler = pusher.onError(reject);
+    const destroy = () => {
+        unsubErrorHandler();
+        pusher.unsubscribe(token);
+    };
+    onCancel(signal, () => {
+        destroy();
+        reject(cancelError('pusher cancelled'));
+    });
+    pusher.subscribe(token, (result) => {
+        switch (result.status) {
+            case Status.Progress: {
+                if (onProgress) {
+                    if (result.total === 'unknown') {
+                        onProgress({ isComputable: false });
+                    }
+                    else {
+                        onProgress({
+                            isComputable: true,
+                            value: result.done / result.total
+                        });
+                    }
+                }
+                break;
+            }
+            case Status.Success: {
+                destroy();
+                if (onProgress)
+                    onProgress({
+                        isComputable: true,
+                        value: result.done / result.total
+                    });
+                resolve(result);
+                break;
+            }
+            case Status.Error: {
+                destroy();
+                reject(new UploadClientError(result.msg, result.error_code));
+            }
+        }
+    });
+});
+const uploadFromUrl = (sourceUrl, { publicKey, fileName, baseURL, baseCDN, checkForUrlDuplicates, saveUrlForRecurrentUploads, secureSignature, secureExpire, store, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, pusherKey = defaultSettings.pusherKey, metadata }) => Promise.resolve(preconnect(pusherKey))
+    .then(() => fromUrl(sourceUrl, {
+    publicKey,
+    fileName,
+    baseURL,
+    checkForUrlDuplicates,
+    saveUrlForRecurrentUploads,
+    secureSignature,
+    secureExpire,
+    store,
+    signal,
+    source,
+    integration,
+    userAgent,
+    retryThrottledRequestMaxTimes,
+    metadata
+}))
+    .catch((error) => {
+    const pusher = getPusher(pusherKey);
+    pusher === null || pusher === void 0 ? void 0 : pusher.disconnect();
+    return Promise.reject(error);
+})
+    .then((urlResponse) => {
+    if (urlResponse.type === TypeEnum.FileInfo) {
+        return urlResponse;
+    }
+    else {
+        return race([
+            ({ signal }) => pollStrategy({
+                token: urlResponse.token,
+                publicKey,
+                baseURL,
+                integration,
+                userAgent,
+                retryThrottledRequestMaxTimes,
+                onProgress,
+                signal
+            }),
+            ({ signal }) => pushStrategy({
+                token: urlResponse.token,
+                pusherKey,
+                signal,
+                onProgress
+            })
+        ], { signal });
+    }
+})
+    .then((result) => {
+    if (result instanceof UploadClientError)
+        throw result;
+    return result;
+})
+    .then((result) => isReadyPoll({
+    file: result.uuid,
+    publicKey,
+    baseURL,
+    integration,
+    userAgent,
+    retryThrottledRequestMaxTimes,
+    onProgress,
+    signal
+}))
     .then((fileInfo) => new UploadcareFile(fileInfo, { baseCDN }));
-const uploadFromUploaded = (uuid, { publicKey, fileName, baseURL, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, baseCDN }) => {
-    return info(uuid, {
-        publicKey,
-        baseURL,
-        signal,
-        source,
-        integration,
-        userAgent,
-        retryThrottledRequestMaxTimes
-    })
-        .then((fileInfo) => new UploadcareFile(fileInfo, { baseCDN, fileName }))
-        .then((result) => {
-        // hack for node ¯\_(ツ)_/¯
-        if (onProgress)
-            onProgress({
-                isComputable: true,
-                value: 1
-            });
-        return result;
-    });
+const uploadFromUploaded = (uuid, { publicKey, fileName, baseURL, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, baseCDN }) => {
+    return info(uuid, {
+        publicKey,
+        baseURL,
+        signal,
+        source,
+        integration,
+        userAgent,
+        retryThrottledRequestMaxTimes
+    })
+        .then((fileInfo) => new UploadcareFile(fileInfo, { baseCDN, fileName }))
+        .then((result) => {
+        // hack for node ¯\_(ツ)_/¯
+        if (onProgress)
+            onProgress({
+                isComputable: true,
+                value: 1
+            });
+        return result;
+    });
 };
-/**
- * Get file size.
- */
-const getFileSize = (file) => {
-    return file.length || file.size;
-};
-/**
- * Check if FileData is multipart data.
- */
-const isMultipart = (fileSize, multipartMinFileSize = defaultSettings.multipartMinFileSize) => {
-    return fileSize >= multipartMinFileSize;
+/**
+ * Get file size.
+ */
+const getFileSize = (file) => {
+    return file.length || file.size;
+};
+/**
+ * Check if FileData is multipart data.
+ */
+const isMultipart = (fileSize, multipartMinFileSize = defaultSettings.multipartMinFileSize) => {
+    return fileSize >= multipartMinFileSize;
 };
-const sliceChunk = (file, index, fileSize, chunkSize) => {
-    const start = chunkSize * index;
-    const end = Math.min(start + chunkSize, fileSize);
-    return file.slice(start, end);
+const sliceChunk = (file, index, fileSize, chunkSize) => {
+    const start = chunkSize * index;
+    const end = Math.min(start + chunkSize, fileSize);
+    return file.slice(start, end);
 };
-function prepareChunks(file, fileSize, chunkSize) {
-    return (index) => sliceChunk(file, index, fileSize, chunkSize);
+function prepareChunks(file, fileSize, chunkSize) {
+    return (index) => sliceChunk(file, index, fileSize, chunkSize);
 }
-const runWithConcurrency = (concurrency, tasks) => {
-    return new Promise((resolve, reject) => {
-        const results = [];
-        let rejected = false;
-        let settled = tasks.length;
-        const forRun = [...tasks];
-        const run = () => {
-            const index = tasks.length - forRun.length;
-            const next = forRun.shift();
-            if (next) {
-                next()
-                    .then((result) => {
-                    if (rejected)
-                        return;
-                    results[index] = result;
-                    settled -= 1;
-                    if (settled) {
-                        run();
-                    }
-                    else {
-                        resolve(results);
-                    }
-                })
-                    .catch((error) => {
-                    rejected = true;
-                    reject(error);
-                });
-            }
-        };
-        for (let i = 0; i < concurrency; i++) {
-            run();
-        }
-    });
+const runWithConcurrency = (concurrency, tasks) => {
+    return new Promise((resolve, reject) => {
+        const results = [];
+        let rejected = false;
+        let settled = tasks.length;
+        const forRun = [...tasks];
+        const run = () => {
+            const index = tasks.length - forRun.length;
+            const next = forRun.shift();
+            if (next) {
+                next()
+                    .then((result) => {
+                    if (rejected)
+                        return;
+                    results[index] = result;
+                    settled -= 1;
+                    if (settled) {
+                        run();
+                    }
+                    else {
+                        resolve(results);
+                    }
+                })
+                    .catch((error) => {
+                    rejected = true;
+                    reject(error);
+                });
+            }
+        };
+        for (let i = 0; i < concurrency; i++) {
+            run();
+        }
+    });
 };
-const uploadPartWithRetry = (chunk, url, { publicKey, onProgress, signal, integration, multipartMaxAttempts }) => retrier(({ attempt, retry }) => multipartUpload(chunk, url, {
-    publicKey,
-    onProgress,
-    signal,
-    integration
-}).catch((error) => {
-    if (attempt < multipartMaxAttempts) {
-        return retry();
-    }
-    throw error;
-}));
-const uploadMultipart = (file, { publicKey, fileName, fileSize, baseURL, secureSignature, secureExpire, store, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, contentType, multipartChunkSize = defaultSettings.multipartChunkSize, maxConcurrentRequests = defaultSettings.maxConcurrentRequests, multipartMaxAttempts = defaultSettings.multipartMaxAttempts, baseCDN, metadata }) => {
-    const size = fileSize || getFileSize(file);
-    let progressValues;
-    const createProgressHandler = (totalChunks, chunkIdx) => {
-        if (!onProgress)
-            return;
-        if (!progressValues) {
-            progressValues = Array(totalChunks).fill(0);
-        }
-        const sum = (values) => values.reduce((sum, next) => sum + next, 0);
-        return (info) => {
-            if (!info.isComputable) {
-                return;
-            }
-            progressValues[chunkIdx] = info.value;
-            onProgress({
-                isComputable: true,
-                value: sum(progressValues) / totalChunks
-            });
-        };
-    };
-    return multipartStart(size, {
-        publicKey,
-        contentType,
-        fileName: fileName !== null && fileName !== void 0 ? fileName : file.name,
-        baseURL,
-        secureSignature,
-        secureExpire,
-        store,
-        signal,
-        source,
-        integration,
-        userAgent,
-        retryThrottledRequestMaxTimes,
-        metadata
-    })
-        .then(({ uuid, parts }) => {
-        const getChunk = prepareChunks(file, size, multipartChunkSize);
-        return Promise.all([
-            uuid,
-            runWithConcurrency(maxConcurrentRequests, parts.map((url, index) => () => uploadPartWithRetry(getChunk(index), url, {
-                publicKey,
-                onProgress: createProgressHandler(parts.length, index),
-                signal,
-                integration,
-                multipartMaxAttempts
-            })))
-        ]);
-    })
-        .then(([uuid]) => multipartComplete(uuid, {
-        publicKey,
-        baseURL,
-        source,
-        integration,
-        userAgent,
-        retryThrottledRequestMaxTimes
-    }))
-        .then((fileInfo) => {
-        if (fileInfo.isReady) {
-            return fileInfo;
-        }
-        else {
-            return isReadyPoll({
-                file: fileInfo.uuid,
-                publicKey,
-                baseURL,
-                source,
-                integration,
-                userAgent,
-                retryThrottledRequestMaxTimes,
-                onProgress,
-                signal
-            });
-        }
-    })
-        .then((fileInfo) => new UploadcareFile(fileInfo, { baseCDN }));
+const uploadPartWithRetry = (chunk, url, { publicKey, onProgress, signal, integration, multipartMaxAttempts }) => retrier(({ attempt, retry }) => multipartUpload(chunk, url, {
+    publicKey,
+    onProgress,
+    signal,
+    integration
+}).catch((error) => {
+    if (attempt < multipartMaxAttempts) {
+        return retry();
+    }
+    throw error;
+}));
+const uploadMultipart = (file, { publicKey, fileName, fileSize, baseURL, secureSignature, secureExpire, store, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, contentType, multipartChunkSize = defaultSettings.multipartChunkSize, maxConcurrentRequests = defaultSettings.maxConcurrentRequests, multipartMaxAttempts = defaultSettings.multipartMaxAttempts, baseCDN, metadata }) => {
+    const size = fileSize || getFileSize(file);
+    let progressValues;
+    const createProgressHandler = (totalChunks, chunkIdx) => {
+        if (!onProgress)
+            return;
+        if (!progressValues) {
+            progressValues = Array(totalChunks).fill(0);
+        }
+        const sum = (values) => values.reduce((sum, next) => sum + next, 0);
+        return (info) => {
+            if (!info.isComputable) {
+                return;
+            }
+            progressValues[chunkIdx] = info.value;
+            onProgress({
+                isComputable: true,
+                value: sum(progressValues) / totalChunks
+            });
+        };
+    };
+    return multipartStart(size, {
+        publicKey,
+        contentType,
+        fileName: fileName !== null && fileName !== void 0 ? fileName : file.name,
+        baseURL,
+        secureSignature,
+        secureExpire,
+        store,
+        signal,
+        source,
+        integration,
+        userAgent,
+        retryThrottledRequestMaxTimes,
+        metadata
+    })
+        .then(({ uuid, parts }) => {
+        const getChunk = prepareChunks(file, size, multipartChunkSize);
+        return Promise.all([
+            uuid,
+            runWithConcurrency(maxConcurrentRequests, parts.map((url, index) => () => uploadPartWithRetry(getChunk(index), url, {
+                publicKey,
+                onProgress: createProgressHandler(parts.length, index),
+                signal,
+                integration,
+                multipartMaxAttempts
+            })))
+        ]);
+    })
+        .then(([uuid]) => multipartComplete(uuid, {
+        publicKey,
+        baseURL,
+        source,
+        integration,
+        userAgent,
+        retryThrottledRequestMaxTimes
+    }))
+        .then((fileInfo) => {
+        if (fileInfo.isReady) {
+            return fileInfo;
+        }
+        else {
+            return isReadyPoll({
+                file: fileInfo.uuid,
+                publicKey,
+                baseURL,
+                source,
+                integration,
+                userAgent,
+                retryThrottledRequestMaxTimes,
+                onProgress,
+                signal
+            });
+        }
+    })
+        .then((fileInfo) => new UploadcareFile(fileInfo, { baseCDN }));
 };
-/**
- * Uploads file from provided data.
- */
-function uploadFile(data, { publicKey, fileName, baseURL = defaultSettings.baseURL, secureSignature, secureExpire, store, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, contentType, multipartMinFileSize, multipartChunkSize, multipartMaxAttempts, maxConcurrentRequests, baseCDN = defaultSettings.baseCDN, checkForUrlDuplicates, saveUrlForRecurrentUploads, pusherKey, metadata }) {
-    if (isFileData(data)) {
-        const fileSize = getFileSize(data);
-        if (isMultipart(fileSize, multipartMinFileSize)) {
-            return uploadMultipart(data, {
-                publicKey,
-                contentType,
-                multipartChunkSize,
-                multipartMaxAttempts,
-                fileName,
-                baseURL,
-                secureSignature,
-                secureExpire,
-                store,
-                signal,
-                onProgress,
-                source,
-                integration,
-                userAgent,
-                maxConcurrentRequests,
-                retryThrottledRequestMaxTimes,
-                baseCDN,
-                metadata
-            });
-        }
-        return uploadFromObject(data, {
-            publicKey,
-            fileName,
-            baseURL,
-            secureSignature,
-            secureExpire,
-            store,
-            signal,
-            onProgress,
-            source,
-            integration,
-            userAgent,
-            retryThrottledRequestMaxTimes,
-            baseCDN,
-            metadata
-        });
-    }
-    if (isUrl(data)) {
-        return uploadFromUrl(data, {
-            publicKey,
-            fileName,
-            baseURL,
-            baseCDN,
-            checkForUrlDuplicates,
-            saveUrlForRecurrentUploads,
-            secureSignature,
-            secureExpire,
-            store,
-            signal,
-            onProgress,
-            source,
-            integration,
-            userAgent,
-            retryThrottledRequestMaxTimes,
-            pusherKey,
-            metadata
-        });
-    }
-    if (isUuid(data)) {
-        return uploadFromUploaded(data, {
-            publicKey,
-            fileName,
-            baseURL,
-            signal,
-            onProgress,
-            source,
-            integration,
-            userAgent,
-            retryThrottledRequestMaxTimes,
-            baseCDN
-        });
-    }
-    throw new TypeError(`File uploading from "${data}" is not supported`);
+/**
+ * Uploads file from provided data.
+ */
+function uploadFile(data, { publicKey, fileName, baseURL = defaultSettings.baseURL, secureSignature, secureExpire, store, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, contentType, multipartMinFileSize, multipartChunkSize, multipartMaxAttempts, maxConcurrentRequests, baseCDN = defaultSettings.baseCDN, checkForUrlDuplicates, saveUrlForRecurrentUploads, pusherKey, metadata }) {
+    if (isFileData(data)) {
+        const fileSize = getFileSize(data);
+        if (isMultipart(fileSize, multipartMinFileSize)) {
+            return uploadMultipart(data, {
+                publicKey,
+                contentType,
+                multipartChunkSize,
+                multipartMaxAttempts,
+                fileName,
+                baseURL,
+                secureSignature,
+                secureExpire,
+                store,
+                signal,
+                onProgress,
+                source,
+                integration,
+                userAgent,
+                maxConcurrentRequests,
+                retryThrottledRequestMaxTimes,
+                baseCDN,
+                metadata
+            });
+        }
+        return uploadDirect(data, {
+            publicKey,
+            fileName,
+            contentType,
+            baseURL,
+            secureSignature,
+            secureExpire,
+            store,
+            signal,
+            onProgress,
+            source,
+            integration,
+            userAgent,
+            retryThrottledRequestMaxTimes,
+            baseCDN,
+            metadata
+        });
+    }
+    if (isUrl(data)) {
+        return uploadFromUrl(data, {
+            publicKey,
+            fileName,
+            baseURL,
+            baseCDN,
+            checkForUrlDuplicates,
+            saveUrlForRecurrentUploads,
+            secureSignature,
+            secureExpire,
+            store,
+            signal,
+            onProgress,
+            source,
+            integration,
+            userAgent,
+            retryThrottledRequestMaxTimes,
+            pusherKey,
+            metadata
+        });
+    }
+    if (isUuid(data)) {
+        return uploadFromUploaded(data, {
+            publicKey,
+            fileName,
+            baseURL,
+            signal,
+            onProgress,
+            source,
+            integration,
+            userAgent,
+            retryThrottledRequestMaxTimes,
+            baseCDN
+        });
+    }
+    throw new TypeError(`File uploading from "${data}" is not supported`);
 }
-class UploadcareGroup {
-    constructor(groupInfo, files) {
-        this.storedAt = null;
-        this.uuid = groupInfo.id;
-        this.filesCount = groupInfo.filesCount;
-        this.totalSize = Object.values(groupInfo.files).reduce((acc, file) => acc + file.size, 0);
-        this.isStored = !!groupInfo.datetimeStored;
-        this.isImage = !!Object.values(groupInfo.files).filter((file) => file.isImage).length;
-        this.cdnUrl = groupInfo.cdnUrl;
-        this.files = files;
-        this.createdAt = groupInfo.datetimeCreated;
-        this.storedAt = groupInfo.datetimeStored;
-    }
+class UploadcareGroup {
+    constructor(groupInfo, files) {
+        this.storedAt = null;
+        this.uuid = groupInfo.id;
+        this.filesCount = groupInfo.filesCount;
+        this.totalSize = Object.values(groupInfo.files).reduce((acc, file) => acc + file.size, 0);
+        this.isStored = !!groupInfo.datetimeStored;
+        this.isImage = !!Object.values(groupInfo.files).filter((file) => file.isImage).length;
+        this.cdnUrl = groupInfo.cdnUrl;
+        this.files = files;
+        this.createdAt = groupInfo.datetimeCreated;
+        this.storedAt = groupInfo.datetimeStored;
+    }
 }
-/**
- * FileData type guard.
- */
-const isFileDataArray = (data) => {
-    for (const item of data) {
-        if (!isFileData(item)) {
-            return false;
-        }
-    }
-    return true;
-};
-/**
- * Uuid type guard.
- */
-const isUuidArray = (data) => {
-    for (const item of data) {
-        if (!isUuid(item)) {
-            return false;
-        }
-    }
-    return true;
-};
-/**
- * Url type guard.
- */
-const isUrlArray = (data) => {
-    for (const item of data) {
-        if (!isUrl(item)) {
-            return false;
-        }
-    }
-    return true;
+/**
+ * FileData type guard.
+ */
+const isFileDataArray = (data) => {
+    for (const item of data) {
+        if (!isFileData(item)) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Uuid type guard.
+ */
+const isUuidArray = (data) => {
+    for (const item of data) {
+        if (!isUuid(item)) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Url type guard.
+ */
+const isUrlArray = (data) => {
+    for (const item of data) {
+        if (!isUrl(item)) {
+            return false;
+        }
+    }
+    return true;
 };
-function uploadFileGroup(data, { publicKey, fileName, baseURL = defaultSettings.baseURL, secureSignature, secureExpire, store, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, contentType, multipartChunkSize = defaultSettings.multipartChunkSize, baseCDN = defaultSettings.baseCDN, jsonpCallback, defaultEffects }) {
-    if (!isFileDataArray(data) && !isUrlArray(data) && !isUuidArray(data)) {
-        throw new TypeError(`Group uploading from "${data}" is not supported`);
-    }
-    let progressValues;
-    let isStillComputable = true;
-    const filesCount = data.length;
-    const createProgressHandler = (size, index) => {
-        if (!onProgress)
-            return;
-        if (!progressValues) {
-            progressValues = Array(size).fill(0);
-        }
-        const normalize = (values) => values.reduce((sum, next) => sum + next) / size;
-        return (info) => {
-            if (!info.isComputable || !isStillComputable) {
-                isStillComputable = false;
-                onProgress({ isComputable: false });
-                return;
-            }
-            progressValues[index] = info.value;
-            onProgress({ isComputable: true, value: normalize(progressValues) });
-        };
-    };
-    return Promise.all(data.map((file, index) => uploadFile(file, {
-        publicKey,
-        fileName,
-        baseURL,
-        secureSignature,
-        secureExpire,
-        store,
-        signal,
-        onProgress: createProgressHandler(filesCount, index),
-        source,
-        integration,
-        userAgent,
-        retryThrottledRequestMaxTimes,
-        contentType,
-        multipartChunkSize,
-        baseCDN
-    }))).then((files) => {
-        const uuids = files.map((file) => file.uuid);
-        const addDefaultEffects = (file) => {
-            const cdnUrlModifiers = defaultEffects ? `-/${defaultEffects}` : null;
-            const cdnUrl = `${file.urlBase}${cdnUrlModifiers || ''}`;
-            return Object.assign(Object.assign({}, file), { cdnUrlModifiers,
-                cdnUrl });
-        };
-        const filesInGroup = defaultEffects ? files.map(addDefaultEffects) : files;
-        return group(uuids, {
-            publicKey,
-            baseURL,
-            jsonpCallback,
-            secureSignature,
-            secureExpire,
-            signal,
-            source,
-            integration,
-            userAgent,
-            retryThrottledRequestMaxTimes
-        })
-            .then((groupInfo) => new UploadcareGroup(groupInfo, filesInGroup))
-            .then((group) => {
-            onProgress && onProgress({ isComputable: true, value: 1 });
-            return group;
-        });
-    });
+function uploadFileGroup(data, { publicKey, fileName, baseURL = defaultSettings.baseURL, secureSignature, secureExpire, store, signal, onProgress, source, integration, userAgent, retryThrottledRequestMaxTimes, contentType, multipartChunkSize = defaultSettings.multipartChunkSize, baseCDN = defaultSettings.baseCDN, jsonpCallback }) {
+    if (!isFileDataArray(data) && !isUrlArray(data) && !isUuidArray(data)) {
+        throw new TypeError(`Group uploading from "${data}" is not supported`);
+    }
+    let progressValues;
+    let isStillComputable = true;
+    const filesCount = data.length;
+    const createProgressHandler = (size, index) => {
+        if (!onProgress)
+            return;
+        if (!progressValues) {
+            progressValues = Array(size).fill(0);
+        }
+        const normalize = (values) => values.reduce((sum, next) => sum + next) / size;
+        return (info) => {
+            if (!info.isComputable || !isStillComputable) {
+                isStillComputable = false;
+                onProgress({ isComputable: false });
+                return;
+            }
+            progressValues[index] = info.value;
+            onProgress({ isComputable: true, value: normalize(progressValues) });
+        };
+    };
+    return Promise.all(data.map((file, index) => uploadFile(file, {
+        publicKey,
+        fileName,
+        baseURL,
+        secureSignature,
+        secureExpire,
+        store,
+        signal,
+        onProgress: createProgressHandler(filesCount, index),
+        source,
+        integration,
+        userAgent,
+        retryThrottledRequestMaxTimes,
+        contentType,
+        multipartChunkSize,
+        baseCDN
+    }))).then((files) => {
+        const uuids = files.map((file) => file.uuid);
+        return group(uuids, {
+            publicKey,
+            baseURL,
+            jsonpCallback,
+            secureSignature,
+            secureExpire,
+            signal,
+            source,
+            integration,
+            userAgent,
+            retryThrottledRequestMaxTimes
+        })
+            .then((groupInfo) => new UploadcareGroup(groupInfo, files))
+            .then((group) => {
+            onProgress && onProgress({ isComputable: true, value: 1 });
+            return group;
+        });
+    });
 }
-/**
- * Populate options with settings.
- */
-const populateOptionsWithSettings = (options, settings) => (Object.assign(Object.assign({}, settings), options));
-class UploadClient {
-    constructor(settings) {
-        this.settings = Object.assign({}, defaultSettings, settings);
-    }
-    updateSettings(newSettings) {
-        this.settings = Object.assign(this.settings, newSettings);
-    }
-    getSettings() {
-        return this.settings;
-    }
-    base(file, options) {
-        const settings = this.getSettings();
-        return base(file, populateOptionsWithSettings(options, settings));
-    }
-    info(uuid, options) {
-        const settings = this.getSettings();
-        return info(uuid, populateOptionsWithSettings(options, settings));
-    }
-    fromUrl(sourceUrl, options) {
-        const settings = this.getSettings();
-        return fromUrl(sourceUrl, populateOptionsWithSettings(options, settings));
-    }
-    fromUrlStatus(token, options) {
-        const settings = this.getSettings();
-        return fromUrlStatus(token, populateOptionsWithSettings(options, settings));
-    }
-    group(uuids, options) {
-        const settings = this.getSettings();
-        return group(uuids, populateOptionsWithSettings(options, settings));
-    }
-    groupInfo(id, options) {
-        const settings = this.getSettings();
-        return groupInfo(id, populateOptionsWithSettings(options, settings));
-    }
-    multipartStart(size, options) {
-        const settings = this.getSettings();
-        return multipartStart(size, populateOptionsWithSettings(options, settings));
-    }
-    multipartUpload(part, url, options) {
-        const settings = this.getSettings();
-        return multipartUpload(part, url, populateOptionsWithSettings(options, settings));
-    }
-    multipartComplete(uuid, options) {
-        const settings = this.getSettings();
-        return multipartComplete(uuid, populateOptionsWithSettings(options, settings));
-    }
-    uploadFile(data, options) {
-        const settings = this.getSettings();
-        return uploadFile(data, populateOptionsWithSettings(options, settings));
-    }
-    uploadFileGroup(data, options) {
-        const settings = this.getSettings();
-        return uploadFileGroup(data, populateOptionsWithSettings(options, settings));
-    }
+/**
+ * Populate options with settings.
+ */
+const populateOptionsWithSettings = (options, settings) => (Object.assign(Object.assign({}, settings), options));
+class UploadClient {
+    constructor(settings) {
+        this.settings = Object.assign({}, defaultSettings, settings);
+    }
+    updateSettings(newSettings) {
+        this.settings = Object.assign(this.settings, newSettings);
+    }
+    getSettings() {
+        return this.settings;
+    }
+    base(file, options = {}) {
+        const settings = this.getSettings();
+        return base(file, populateOptionsWithSettings(options, settings));
+    }
+    info(uuid, options = {}) {
+        const settings = this.getSettings();
+        return info(uuid, populateOptionsWithSettings(options, settings));
+    }
+    fromUrl(sourceUrl, options = {}) {
+        const settings = this.getSettings();
+        return fromUrl(sourceUrl, populateOptionsWithSettings(options, settings));
+    }
+    fromUrlStatus(token, options = {}) {
+        const settings = this.getSettings();
+        return fromUrlStatus(token, populateOptionsWithSettings(options, settings));
+    }
+    group(uuids, options = {}) {
+        const settings = this.getSettings();
+        return group(uuids, populateOptionsWithSettings(options, settings));
+    }
+    groupInfo(id, options = {}) {
+        const settings = this.getSettings();
+        return groupInfo(id, populateOptionsWithSettings(options, settings));
+    }
+    multipartStart(size, options = {}) {
+        const settings = this.getSettings();
+        return multipartStart(size, populateOptionsWithSettings(options, settings));
+    }
+    multipartUpload(part, url, options = {}) {
+        const settings = this.getSettings();
+        return multipartUpload(part, url, populateOptionsWithSettings(options, settings));
+    }
+    multipartComplete(uuid, options = {}) {
+        const settings = this.getSettings();
+        return multipartComplete(uuid, populateOptionsWithSettings(options, settings));
+    }
+    uploadFile(data, options = {}) {
+        const settings = this.getSettings();
+        return uploadFile(data, populateOptionsWithSettings(options, settings));
+    }
+    uploadFileGroup(data, options = {}) {
+        const settings = this.getSettings();
+        return uploadFileGroup(data, populateOptionsWithSettings(options, settings));
+    }
 }
-export { UploadClient, UploadClientError, UploadcareFile, UploadcareGroup, base, fromUrl, fromUrlStatus, group, groupInfo, info, multipartComplete, multipartStart, multipartUpload, uploadFromObject as uploadBase, uploadFile, uploadFileGroup, uploadFromUploaded, uploadFromUrl, uploadMultipart };
+export { UploadClient, UploadClientError, UploadcareFile, UploadcareGroup, base, fromUrl, fromUrlStatus, group, groupInfo, info, multipartComplete, multipartStart, multipartUpload, uploadDirect, uploadFile, uploadFileGroup, uploadFromUploaded, uploadFromUrl, uploadMultipart };