uploadcare-widget/uploadcare.api.js

Uploadcare Widget: file uploader.

/**
 * uploadcare-widget 3.9.1
 * Date: 2020-04-13
 */

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('jquery')) :
  typeof define === 'function' && define.amd ? define(['jquery'], factory) :
  (global = global || self, global.uploadcare = factory(global.$));
}(this, (function ($) { 'use strict';

  $ = $ && $.hasOwnProperty('default') ? $['default'] : $;

  function _typeof(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      _typeof = function (obj) {
        return typeof obj;
      };
    } else {
      _typeof = function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }

    return _typeof(obj);
  }

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
  }

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) _setPrototypeOf(subClass, superClass);
  }

  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (typeof call === "object" || typeof call === "function")) {
      return call;
    }

    return _assertThisInitialized(self);
  }

  function _superPropBase(object, property) {
    while (!Object.prototype.hasOwnProperty.call(object, property)) {
      object = _getPrototypeOf(object);
      if (object === null) break;
    }

    return object;
  }

  function _get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
      _get = Reflect.get;
    } else {
      _get = function _get(target, property, receiver) {
        var base = _superPropBase(target, property);

        if (!base) return;
        var desc = Object.getOwnPropertyDescriptor(base, property);

        if (desc.get) {
          return desc.get.call(receiver);
        }

        return desc.value;
      };
    }

    return _get(target, property, receiver || target);
  }

  function _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
  }

  function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
  }

  function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

      return arr2;
    }
  }

  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function _iterableToArray(iter) {
    if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
  }

  function _iterableToArrayLimit(arr, i) {
    if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
      return;
    }

    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance");
  }

  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance");
  }

  var isWindowDefined = function isWindowDefined() {
    return (typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object';
  };

  var isWindowDefined$1 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    isWindowDefined: isWindowDefined
  });

  if (isWindowDefined() && window.XDomainRequest) {
    $.ajaxTransport(function (s) {
      if (s.crossDomain && s.async) {
        if (s.timeout) {
          s.xdrTimeout = s.timeout;
          delete s.timeout;
        }

        var xdr;
        return {
          send: function send(_, complete) {
            function callback(status, statusText, responses, responseHeaders) {
              xdr.onload = xdr.onerror = xdr.ontimeout = function () {};

              xdr = undefined;
              complete(status, statusText, responses, responseHeaders);
            }

            xdr = new XDomainRequest();

            xdr.onload = function () {
              callback(200, "OK", {
                text: xdr.responseText
              }, "Content-Type: " + xdr.contentType);
            };

            xdr.onerror = function () {
              callback(404, "Not Found");
            };

            xdr.onprogress = function () {};

            xdr.ontimeout = function () {
              callback(0, "timeout");
            };

            xdr.timeout = s.xdrTimeout || Number.MAX_VALUE;
            xdr.open(s.type, s.url.replace(/^https?:/, ''));
            xdr.send(s.hasContent && s.data || null);
          },
          abort: function abort() {
            if (xdr) {
              xdr.onerror = function () {};

              xdr.abort();
            }
          }
        };
      }
    });
  }

  var version = "3.9.1";

  var fileAPI = isWindowDefined() && !!(window.File && window.FileList && window.FileReader);
  var sendFileAPI = isWindowDefined() && !!(window.FormData && fileAPI); // https://github.com/Modernizr/Modernizr/blob/master/feature-detects/draganddrop.js

  var dragAndDrop = isWindowDefined() && function () {
    var el;
    el = document.createElement('div');
    return 'draggable' in el || 'ondragstart' in el && 'ondrop' in el;
  }(); // https://github.com/Modernizr/Modernizr/blob/master/feature-detects/canvas.js


  var canvas = isWindowDefined() && function () {
    var el;
    el = document.createElement('canvas');
    return !!(el.getContext && el.getContext('2d'));
  }();

  var fileDragAndDrop = fileAPI && dragAndDrop;
  var iOSVersion = null; // TODO: don't access to navigator in module scope (NODE don't have navigator)

  var ios = isWindowDefined() && /^[^(]+\(iP(?:hone|od|ad);\s*(.+?)\)/.exec(navigator.userAgent);

  if (ios) {
    var ver = /OS (\d)_(\d)/.exec(ios[1]);

    if (ver) {
      iOSVersion = +ver[1] + ver[2] / 10;
    }
  }

  var Blob = false;

  try {
    if (isWindowDefined() && new window.Blob()) {
      Blob = window.Blob;
    }
  } catch (error) {}

  var url = isWindowDefined() && (window.URL || window.webkitURL || false);
  var URL = url && url.createObjectURL && url;
  var FileReader = isWindowDefined() && (window.FileReader != null ? window.FileReader.prototype.readAsArrayBuffer : undefined) && window.FileReader;

  // utils
  var log = function log() {
    var ref;

    try {
      var _ref;

      return (ref = window.console) != null ? typeof ref.log === 'function' ? (_ref = ref).log.apply(_ref, arguments) : undefined : undefined;
    } catch (error) {}
  };

  var debug = function debug() {
    var ref;

    if ((ref = window.console) != null ? ref.debug : undefined) {
      try {
        var _window$console;

        return (_window$console = window.console).debug.apply(_window$console, arguments);
      } catch (error) {}
    } else {
      return log.apply(void 0, ['Debug:'].concat(Array.prototype.slice.call(arguments)));
    }
  };

  var warn = function warn() {
    var ref;

    if ((ref = window.console) != null ? ref.warn : undefined) {
      try {
        var _window$console2;

        return (_window$console2 = window.console).warn.apply(_window$console2, arguments);
      } catch (error) {}
    } else {
      return log.apply(void 0, ['Warning:'].concat(Array.prototype.slice.call(arguments)));
    }
  };

  var messages = {};

  var warnOnce = function warnOnce(msg) {
    if (messages[msg] == null) {
      messages[msg] = true;
      return warn(msg);
    }
  };

  var indexOf = [].indexOf; // utils

  var unique = function unique(arr) {
    var item, j, len, result;
    result = [];

    for (j = 0, len = arr.length; j < len; j++) {
      item = arr[j];

      if (indexOf.call(result, item) < 0) {
        result.push(item);
      }
    }

    return result;
  };

  var defer = function defer(fn) {
    return setTimeout(fn, 0);
  };

  var gcd = function gcd(a, b) {
    var c;

    while (b) {
      c = a % b;
      a = b;
      b = c;
    }

    return a;
  };

  var once = function once(fn) {
    var called, result;
    called = false;
    result = null;
    return function () {
      if (!called) {
        result = fn.apply(this, arguments);
        called = true;
      }

      return result;
    };
  };

  var wrapToPromise = function wrapToPromise(value) {
    return $.Deferred().resolve(value).promise();
  }; // same as promise.then(), but if filter returns promise
  // it will be just passed forward without any special behavior


  var then = function then(pr, doneFilter, failFilter, progressFilter) {
    var compose, df;
    df = $.Deferred();

    compose = function compose(fn1, fn2) {
      if (fn1 && fn2) {
        return function () {
          return fn2.call(this, fn1.apply(this, arguments));
        };
      } else {
        return fn1 || fn2;
      }
    };

    pr.then(compose(doneFilter, df.resolve), compose(failFilter, df.reject), compose(progressFilter, df.notify));
    return df.promise();
  }; // Build copy of source with only specified methods.
  // Handles chaining correctly.


  var bindAll = function bindAll(source, methods) {
    var target;
    target = {};
    $.each(methods, function (i, method) {
      var fn = source[method];

      if ($.isFunction(fn)) {
        target[method] = function () {
          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }

          var result = fn.apply(source, args); // Fix chaining

          if (result === source) {
            return target;
          } else {
            return result;
          }
        };
      } else {
        target[method] = fn;
      }
    });
    return target;
  };

  var upperCase = function upperCase(s) {
    return s.replace(/([A-Z])/g, '_$1').toUpperCase();
  };

  var publicCallbacks = function publicCallbacks(callbacks) {
    var result;
    result = callbacks.add;
    result.add = callbacks.add;
    result.remove = callbacks.remove;
    return result;
  };

  var uuid = function uuid() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
      var r = Math.random() * 16 | 0;
      var v = c === 'x' ? r : r & 3 | 8;
      return v.toString(16);
    });
  }; // splitUrlRegex("url") => ["url", "scheme", "host", "path", "query", "fragment"]


  var splitUrlRegex = /^(?:([^:/?#]+):)?(?:\/\/([^/?#]*))?([^?#]*)\??([^#]*)#?(.*)$/;
  var uuidRegex = /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i;
  var groupIdRegex = new RegExp("".concat(uuidRegex.source, "~[0-9]+"), 'i');
  var cdnUrlRegex = new RegExp("^/?(".concat(uuidRegex.source, ")(?:/(-/(?:[^/]+/)+)?([^/]*))?$"), 'i');

  var splitCdnUrl = function splitCdnUrl(url) {
    return cdnUrlRegex.exec(splitUrlRegex.exec(url)[3]);
  };

  var escapeRegExp = function escapeRegExp(str) {
    return str.replace(/[\\-\\[]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
  };

  var globRegexp = function globRegexp(str) {
    var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'i';
    var parts;
    parts = $.map(str.split('*'), escapeRegExp);
    return new RegExp('^' + parts.join('.+') + '$', flags);
  };

  var normalizeUrl = function normalizeUrl(url) {
    var scheme; // google.com/ → google.com
    // /google.com/ → /google.com
    // //google.com/ → http://google.com
    // http://google.com/ → http://google.com

    scheme = document.location.protocol;

    if (scheme !== 'http:') {
      scheme = 'https:';
    }

    return url.replace(/^\/\//, scheme + '//').replace(/\/+$/, '');
  };

  var fitText = function fitText(text, max) {
    if (text.length > max) {
      var head = Math.ceil((max - 3) / 2);
      var tail = Math.floor((max - 3) / 2);
      return text.slice(0, head) + '...' + text.slice(-tail);
    } else {
      return text;
    }
  };

  var fitSizeInCdnLimit = function fitSizeInCdnLimit(objSize) {
    return fitSize(objSize, [2048, 2048]);
  };

  var fitSize = function fitSize(objSize, boxSize, upscale) {
    var heightRation, widthRatio;

    if (objSize[0] > boxSize[0] || objSize[1] > boxSize[1] || upscale) {
      widthRatio = boxSize[0] / objSize[0];
      heightRation = boxSize[1] / objSize[1];

      if (!boxSize[0] || boxSize[1] && widthRatio > heightRation) {
        return [Math.round(heightRation * objSize[0]), boxSize[1]];
      } else {
        return [boxSize[0], Math.round(widthRatio * objSize[1])];
      }
    } else {
      return objSize.slice();
    }
  };

  var applyCropCoordsToInfo = function applyCropCoordsToInfo(info, crop, size, coords) {
    var downscale, h, modifiers, prefered, upscale, w, wholeImage;
    w = coords.width;
    h = coords.height;
    prefered = crop.preferedSize;
    modifiers = '';
    wholeImage = w === size[0] && h === size[1];

    if (!wholeImage) {
      modifiers += "-/crop/".concat(w, "x").concat(h, "/").concat(coords.left, ",").concat(coords.top, "/");
    }

    downscale = crop.downscale && (w > prefered[0] || h > prefered[1]);
    upscale = crop.upscale && (w < prefered[0] || h < prefered[1]);

    if (downscale || upscale) {
      var _prefered = prefered;

      var _prefered2 = _slicedToArray(_prefered, 2);

      coords.sw = _prefered2[0];
      coords.sh = _prefered2[1];
      modifiers += "-/resize/".concat(prefered.join('x'), "/");
    } else if (!wholeImage) {
      modifiers += '-/preview/';
    }

    info = $.extend({}, info);
    info.cdnUrlModifiers = modifiers;
    info.cdnUrl = "".concat(info.originalUrl).concat(modifiers || '');
    info.crop = coords;
    return info;
  };

  var fileInput = function fileInput(container, settings, fn) {
    var accept, input, _run;

    input = null;
    accept = settings.inputAcceptTypes;

    if (accept === '') {
      accept = settings.imagesOnly ? 'image/*' : null;
    }

    (_run = function run() {
      input = (settings.multiple ? $('<input type="file" multiple>') : $('<input type="file">')).attr('accept', accept).css({
        position: 'absolute',
        top: 0,
        opacity: 0,
        margin: 0,
        padding: 0,
        width: 'auto',
        height: 'auto',
        cursor: container.css('cursor')
      }).on('change', function () {
        fn(this);
        $(this).hide();
        return _run();
      });
      return container.append(input);
    })();

    return container.css({
      position: 'relative',
      overflow: 'hidden' // to make it posible to set `cursor:pointer` on button
      // http://stackoverflow.com/a/9182787/478603

    }).mousemove(function (e) {
      var left, top, width;

      var _$$offset = $(this).offset();

      left = _$$offset.left;
      top = _$$offset.top;
      width = input.width();
      return input.css({
        left: e.pageX - left - width + 10,
        top: e.pageY - top - 10
      });
    });
  };

  var fileSelectDialog = function fileSelectDialog(container, settings, fn) {
    var attributes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
    var accept;
    accept = settings.inputAcceptTypes;

    if (accept === '') {
      accept = settings.imagesOnly ? 'image/*' : null;
    }

    return $(settings.multiple ? '<input type="file" multiple>' : '<input type="file">').attr('accept', accept).attr(attributes).css({
      position: 'fixed',
      bottom: 0,
      opacity: 0
    }).on('change', function () {
      fn(this);
      return $(this).remove();
    }).appendTo(container).focus().click().hide();
  };

  var fileSizeLabels = 'B KB MB GB TB PB EB ZB YB'.split(' ');

  var readableFileSize = function readableFileSize(value) {
    var onNaN = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
    var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
    var postfix = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
    var digits, fixedTo, i, threshold;
    value = parseInt(value, 10);

    if (isNaN(value)) {
      return onNaN;
    }

    digits = 2;
    i = 0;
    threshold = 1000 - 5 * Math.pow(10, 2 - Math.max(digits, 3));

    while (value > threshold && i < fileSizeLabels.length - 1) {
      i++;
      value /= 1024;
    }

    value += 0.000000000000001;
    fixedTo = Math.max(0, digits - Math.floor(value).toFixed(0).length); // fixed → number → string, to trim trailing zeroes

    value = Number(value.toFixed(fixedTo)); // eslint-disable-next-line no-irregular-whitespace

    return "".concat(prefix).concat(value, "\xA0").concat(fileSizeLabels[i]).concat(postfix);
  };

  var ajaxDefaults = {
    dataType: 'json',
    crossDomain: true,
    cache: false
  };

  var jsonp = function jsonp(url, type, data) {
    var settings = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
    return $.ajax($.extend({
      url: url,
      type: type,
      data: data
    }, settings, ajaxDefaults)).then(function (data) {
      var text;

      if (data.error) {
        text = data.error.content || data.error;
        return $.Deferred().reject(text);
      } else {
        return data;
      }
    }, function (_, textStatus, errorThrown) {
      var text;
      text = "".concat(textStatus, " (").concat(errorThrown, ")");
      warn("JSONP unexpected error: ".concat(text, " while loading ").concat(url));
      return text;
    });
  };

  var canvasToBlob = function canvasToBlob(canvas, type, quality, callback) {
    var arr, binStr, dataURL, i, j, ref;

    if (window.HTMLCanvasElement.prototype.toBlob) {
      return canvas.toBlob(callback, type, quality);
    }

    dataURL = canvas.toDataURL(type, quality);
    dataURL = dataURL.split(',');
    binStr = window.atob(dataURL[1]);
    arr = new Uint8Array(binStr.length);

    for (i = j = 0, ref = binStr.length; j < ref; i = j += 1) {
      arr[i] = binStr.charCodeAt(i);
    }

    return callback(new window.Blob([arr], {
      type: /:(.+\/.+);/.exec(dataURL[0])[1]
    }));
  };

  var taskRunner = function taskRunner(capacity) {
    var queue, _release, run, running;

    running = 0;
    queue = [];

    _release = function release() {
      var task;

      if (queue.length) {
        task = queue.shift();
        return defer(function () {
          return task(_release);
        });
      } else {
        running -= 1;
        return running;
      }
    };

    run = function run(task) {
      if (!capacity || running < capacity) {
        running += 1;
        return defer(function () {
          return task(_release);
        });
      } else {
        return queue.push(task);
      }
    };

    return run;
  }; // This is work around bug in jquery https://github.com/jquery/jquery/issues/2013
  // action, add listener, callbacks,
  // ... .then handlers, argument index, [final state]


  var pipeTuples = [['notify', 'progress', 2], ['resolve', 'done', 0], ['reject', 'fail', 1]];

  var fixedPipe = function fixedPipe(promise) {
    for (var _len2 = arguments.length, fns = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
      fns[_key2 - 1] = arguments[_key2];
    }

    return $.Deferred(function (newDefer) {
      return $.each(pipeTuples, function (i, tuple) {
        var fn; // Map tuples (progress, done, fail) to arguments (done, fail, progress)

        fn = $.isFunction(fns[tuple[2]]) && fns[tuple[2]];
        return promise[tuple[1]](function () {
          var returned;
          returned = fn && fn.apply(this, arguments);

          if (returned && $.isFunction(returned.promise)) {
            return returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
          } else {
            return newDefer[tuple[0] + 'With'](this === promise ? newDefer.promise() : this, fn ? [returned] : arguments);
          }
        });
      });
    }).promise();
  };

  var indexOf$1 = [].indexOf; // settings

  var arrayOptions, constrainOptions, constraints, defaultPreviewUrlCallback, defaults, flagOptions, intOptions, integration, integrationToUserAgent, normalize, parseCrop, parseShrink, presets, script, str2arr, transformOptions, transforms, urlOptions;
  defaults = {
    // developer hooks
    live: true,
    manualStart: false,
    locale: null,
    localePluralize: null,
    localeTranslations: null,
    // widget & dialog settings
    systemDialog: false,
    crop: false,
    previewStep: false,
    imagesOnly: false,
    clearable: false,
    multiple: false,
    multipleMax: 1000,
    multipleMin: 1,
    multipleMaxStrict: false,
    imageShrink: false,
    pathValue: true,
    tabs: 'file camera url facebook gdrive gphotos dropbox instagram evernote flickr onedrive',
    preferredTypes: '',
    inputAcceptTypes: '',
    // '' means default, null means "disable accept"
    // upload settings
    doNotStore: false,
    publicKey: null,
    secureSignature: '',
    secureExpire: '',
    pusherKey: '79ae88bd931ea68464d9',
    cdnBase: 'https://ucarecdn.com',
    urlBase: 'https://upload.uploadcare.com',
    socialBase: 'https://social.uploadcare.com',
    previewProxy: null,
    previewUrlCallback: null,
    // fine tuning
    imagePreviewMaxSize: 25 * 1024 * 1024,
    multipartMinSize: 10 * 1024 * 1024,
    multipartPartSize: 5 * 1024 * 1024,
    multipartMinLastPartSize: 1024 * 1024,
    multipartConcurrency: 4,
    multipartMaxAttempts: 3,
    parallelDirectUploads: 10,
    passWindowOpen: false,
    // camera recording
    videoPreferredMimeTypes: null,
    audioBitsPerSecond: null,
    videoBitsPerSecond: null,
    // maintain settings
    scriptBase: "//ucarecdn.com/widget/".concat(version, "/uploadcare/"),
    debugUploads: false,
    integration: ''
  };
  transforms = {
    multipleMax: {
      from: 0,
      to: 1000
    }
  };
  constraints = {
    multipleMax: {
      min: 1,
      max: 1000
    }
  };
  presets = {
    tabs: {
      all: 'file camera url facebook gdrive gphotos dropbox instagram evernote flickr onedrive box vk huddle',
      default: defaults.tabs
    }
  }; // integration setting from data attributes of script tag

  script = isWindowDefined() && (document.currentScript || function () {
    var scripts;
    scripts = document.getElementsByTagName('script');
    return scripts[scripts.length - 1];
  }());

  integration = isWindowDefined() && $(script).data('integration');

  if (integration && integration != null) {
    defaults = $.extend(defaults, {
      integration: integration
    });
  }

  str2arr = function str2arr(value) {
    if (!$.isArray(value)) {
      value = $.trim(value);
      value = value ? value.split(' ') : [];
    }

    return value;
  };

  arrayOptions = function arrayOptions(settings, keys) {
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    var i, item, j, key, len, len1, source, value;

    for (i = 0, len = keys.length; i < len; i++) {
      key = keys[i];
      value = source = str2arr(settings[key]);

      if (hasOwnProperty.apply(presets, [key])) {
        value = [];

        for (j = 0, len1 = source.length; j < len1; j++) {
          item = source[j];

          if (hasOwnProperty.apply(presets[key], [item])) {
            value = value.concat(str2arr(presets[key][item]));
          } else {
            value.push(item);
          }
        }
      }

      settings[key] = unique(value);
    }

    return settings;
  };

  urlOptions = function urlOptions(settings, keys) {
    var i, key, len;

    for (i = 0, len = keys.length; i < len; i++) {
      key = keys[i];

      if (settings[key] != null) {
        settings[key] = normalizeUrl(settings[key]);
      }
    }

    return settings;
  };

  flagOptions = function flagOptions(settings, keys) {
    var i, key, len, value;

    for (i = 0, len = keys.length; i < len; i++) {
      key = keys[i];

      if (!(settings[key] != null)) {
        continue;
      }

      value = settings[key];

      if (typeof value === 'string') {
        // "", "..." -> true
        // "false", "disabled" -> false
        value = $.trim(value).toLowerCase();
        settings[key] = !(value === 'false' || value === 'disabled');
      } else {
        settings[key] = !!value;
      }
    }

    return settings;
  };

  intOptions = function intOptions(settings, keys) {
    var i, key, len;

    for (i = 0, len = keys.length; i < len; i++) {
      key = keys[i];

      if (settings[key] != null) {
        settings[key] = parseInt(settings[key]);
      }
    }

    return settings;
  };

  integrationToUserAgent = function integrationToUserAgent(settings) {
    settings._userAgent = "UploadcareWidget/".concat(version, "/").concat(settings.publicKey, " (JavaScript").concat(settings.integration ? "; ".concat(settings.integration) : '', ")");
    return settings;
  };

  transformOptions = function transformOptions(settings, transforms) {
    var key, transform;

    for (key in transforms) {
      transform = transforms[key];

      if (settings[key] != null) {
        if (settings[key] === transform.from) {
          settings[key] = transform.to;
        }
      }
    }

    return settings;
  };

  constrainOptions = function constrainOptions(settings, constraints) {
    var key, max, min;

    for (key in constraints) {
      var _constraints$key = constraints[key];
      min = _constraints$key.min;
      max = _constraints$key.max;

      if (settings[key] != null) {
        settings[key] = Math.min(Math.max(settings[key], min), max);
      }
    }

    return settings;
  };

  parseCrop = function parseCrop(val) {
    var ratio, reRatio;
    reRatio = /^([0-9]+)([x:])([0-9]+)\s*(|upscale|minimum)$/i;
    ratio = reRatio.exec($.trim(val.toLowerCase())) || [];
    return {
      downscale: ratio[2] === 'x',
      upscale: !!ratio[4],
      notLess: ratio[4] === 'minimum',
      preferedSize: ratio.length ? [+ratio[1], +ratio[3]] : undefined
    };
  };

  parseShrink = function parseShrink(val) {
    var reShrink, shrink, size;
    reShrink = /^([0-9]+)x([0-9]+)(?:\s+(\d{1,2}|100)%)?$/i;
    shrink = reShrink.exec($.trim(val.toLowerCase())) || [];

    if (!shrink.length) {
      return false;
    }

    size = shrink[1] * shrink[2];

    if (size > 5000000) {
      // ios max canvas square
      warnOnce('Shrinked size can not be larger than 5MP. ' + "You have set ".concat(shrink[1], "x").concat(shrink[2], " (") + "".concat(Math.ceil(size / 1000 / 100) / 10, "MP)."));
      return false;
    }

    return {
      quality: shrink[3] ? shrink[3] / 100 : undefined,
      size: size
    };
  };

  defaultPreviewUrlCallback = function defaultPreviewUrlCallback(url, info) {
    var addAmpersand, addName, addQuery, queryPart;

    if (!this.previewProxy) {
      return url;
    }

    addQuery = !/\?/.test(this.previewProxy);
    addName = addQuery || !/=$/.test(this.previewProxy);
    addAmpersand = !addQuery && !/[&?=]$/.test(this.previewProxy);
    queryPart = encodeURIComponent(url);

    if (addName) {
      queryPart = 'url=' + queryPart;
    }

    if (addAmpersand) {
      queryPart = '&' + queryPart;
    }

    if (addQuery) {
      queryPart = '?' + queryPart;
    }

    return this.previewProxy + queryPart;
  };

  normalize = function normalize(settings) {
    var skydriveIndex;
    arrayOptions(settings, ['tabs', 'preferredTypes', 'videoPreferredMimeTypes']);
    urlOptions(settings, ['cdnBase', 'socialBase', 'urlBase', 'scriptBase']);
    flagOptions(settings, ['doNotStore', 'imagesOnly', 'multiple', 'clearable', 'pathValue', 'previewStep', 'systemDialog', 'debugUploads', 'multipleMaxStrict']);
    intOptions(settings, ['multipleMax', 'multipleMin', 'multipartMinSize', 'multipartPartSize', 'multipartMinLastPartSize', 'multipartConcurrency', 'multipartMaxAttempts', 'parallelDirectUploads']);
    transformOptions(settings, transforms);
    constrainOptions(settings, constraints);
    integrationToUserAgent(settings);

    if (settings.crop !== false && !$.isArray(settings.crop)) {
      if (/^(disabled?|false|null)$/i.test(settings.crop)) {
        settings.crop = false;
      } else if ($.isPlainObject(settings.crop)) {
        // old format
        settings.crop = [settings.crop];
      } else {
        settings.crop = $.map(('' + settings.crop).split(','), parseCrop);
      }
    }

    if (settings.imageShrink && !$.isPlainObject(settings.imageShrink)) {
      settings.imageShrink = parseShrink(settings.imageShrink);
    }

    if (settings.crop || settings.multiple) {
      settings.previewStep = true;
    }

    if (!sendFileAPI) {
      settings.systemDialog = false;
    }

    if (settings.validators) {
      settings.validators = settings.validators.slice();
    }

    if (settings.previewProxy && !settings.previewUrlCallback) {
      settings.previewUrlCallback = defaultPreviewUrlCallback;
    }

    skydriveIndex = settings.tabs.indexOf('skydrive');

    if (skydriveIndex !== -1) {
      settings.tabs[skydriveIndex] = 'onedrive';
    }

    return settings;
  }; // global variables only


  var globals = function globals() {
    var key, scriptSettings, value;
    scriptSettings = {};

    for (key in defaults) {
      value = window["UPLOADCARE_".concat(upperCase(key))];

      if (value != null) {
        scriptSettings[key] = value;
      }
    }

    return scriptSettings;
  }; // Defaults + global variables + global overrides (once from uploadcare.start)
  // Not publicly-accessible


  var common = once(function (settings, ignoreGlobals) {
    var result;

    if (!ignoreGlobals) {
      defaults = $.extend(defaults, globals());
    }

    result = normalize($.extend(defaults, settings || {}));
    waitForSettings.fire(result);
    return result;
  }); // Defaults + global variables + global overrides + local overrides

  var build = function build(settings) {
    var result;
    result = $.extend({}, common());

    if (!$.isEmptyObject(settings)) {
      result = normalize($.extend(result, settings));
    }

    return result;
  };

  var waitForSettings = isWindowDefined() && $.Callbacks('once memory');

  var CssCollector =
  /*#__PURE__*/
  function () {
    function CssCollector() {
      _classCallCheck(this, CssCollector);

      this.urls = [];
      this.styles = [];
    }

    _createClass(CssCollector, [{
      key: "addUrl",
      value: function addUrl(url) {
        if (!/^https?:\/\//i.test(url)) {
          throw new Error('Embedded urls should be absolute. ' + url);
        }

        if (!(indexOf$1.call(this.urls, url) >= 0)) {
          return this.urls.push(url);
        }
      }
    }, {
      key: "addStyle",
      value: function addStyle(style) {
        return this.styles.push(style);
      }
    }]);

    return CssCollector;
  }();

  var trackLoading = function trackLoading(image, src) {
    var def;
    def = $.Deferred();

    if (src) {
      image.src = src;
    }

    if (image.complete) {
      def.resolve(image);
    } else {
      $(image).one('load', function () {
        return def.resolve(image);
      });
      $(image).one('error', function () {
        return def.reject(image);
      });
    }

    return def.promise();
  };

  var imageLoader = function imageLoader(image) {
    // if argument is an array, treat as
    // load(['1.jpg', '2.jpg'])
    if ($.isArray(image)) {
      return $.when.apply(null, $.map(image, imageLoader));
    }

    if (image.src) {
      return trackLoading(image);
    } else {
      return trackLoading(new window.Image(), image);
    }
  };

  var videoLoader = function videoLoader(src) {
    var def = $.Deferred();
    $('<video/>').on('loadeddata', def.resolve).on('error', def.reject).attr('src', src).get(0).load();
    return def.promise();
  };

  var DataView = isWindowDefined() && window.DataView;
  var runner = taskRunner(1);

  var shrinkFile = function shrinkFile(file, settings) {
    var df; // in -> file
    // out <- blob

    df = $.Deferred();

    if (!(URL && DataView && Blob)) {
      return df.reject('support');
    } // start = new Date()


    runner(function (release) {
      var op; // console.log('delayed: ' + (new Date() - start))

      df.always(release); // start = new Date()

      op = imageLoader(URL.createObjectURL(file));
      op.always(function (img) {
        return URL.revokeObjectURL(img.src);
      });
      op.fail(function () {
        return df.reject('not image');
      });
      return op.done(function (img) {
        // console.log('load: ' + (new Date() - start))
        df.notify(0.1);
        var exifOp = getExif(file).always(function (exif) {
          var e, isJPEG;
          df.notify(0.2);
          isJPEG = exifOp.state() === 'resolved'; // start = new Date()

          op = shrinkImage(img, settings);
          op.progress(function (progress) {
            return df.notify(0.2 + progress * 0.6);
          });
          op.fail(df.reject);
          op.done(function (canvas) {
            var format, quality; // console.log('shrink: ' + (new Date() - start))
            // start = new Date()

            format = 'image/jpeg';
            quality = settings.quality || 0.8;

            if (!isJPEG && hasTransparency(canvas)) {
              format = 'image/png';
              quality = undefined;
            }

            return canvasToBlob(canvas, format, quality, function (blob) {
              canvas.width = canvas.height = 1;
              df.notify(0.9); // console.log('to blob: ' + (new Date() - start))

              if (exif) {
                op = replaceJpegChunk(blob, 0xe1, [exif.buffer]);
                op.done(df.resolve);
                return op.fail(function () {
                  return df.resolve(blob);
                });
              } else {
                return df.resolve(blob);
              }
            });
          });
          e = null; // free reference

          return e;
        });
        return exifOp;
      });
    });
    return df.promise();
  };

  var shrinkImage = function shrinkImage(img, settings) {
    var cx, df, h, maxSize, maxSquare, originalW, ratio, _run, runNative, sH, sW, step, w; // in -> image
    // out <- canvas


    df = $.Deferred();
    step = 0.71; // sohuld be > sqrt(0.5)

    if (img.width * step * img.height * step < settings.size) {
      return df.reject('not required');
    }

    sW = originalW = img.width;
    sH = img.height;
    ratio = sW / sH;
    w = Math.floor(Math.sqrt(settings.size * ratio));
    h = Math.floor(settings.size / Math.sqrt(settings.size * ratio));
    maxSquare = 5000000; // ios max canvas square

    maxSize = 4096; // ie max canvas dimensions

    _run = function run() {
      if (sW <= w) {
        df.resolve(img);
        return;
      }

      return defer(function () {
        var canvas;
        sW = Math.round(sW * step);
        sH = Math.round(sH * step);

        if (sW * step < w) {
          sW = w;
          sH = h;
        }

        if (sW * sH > maxSquare) {
          sW = Math.floor(Math.sqrt(maxSquare * ratio));
          sH = Math.floor(maxSquare / Math.sqrt(maxSquare * ratio));
        }

        if (sW > maxSize) {
          sW = maxSize;
          sH = Math.round(sW / ratio);
        }

        if (sH > maxSize) {
          sH = maxSize;
          sW = Math.round(ratio * sH);
        }

        canvas = document.createElement('canvas');
        canvas.width = sW;
        canvas.height = sH;
        canvas.getContext('2d').drawImage(img, 0, 0, sW, sH);
        img.src = '//:0'; // for image

        img.width = img.height = 1; // for canvas

        img = canvas;
        df.notify((originalW - sW) / (originalW - w));
        return _run();
      });
    };

    runNative = function runNative() {
      var canvas, cx;
      canvas = document.createElement('canvas');
      canvas.width = w;
      canvas.height = h;
      cx = canvas.getContext('2d');
      cx.imageSmoothingQuality = 'high';
      cx.drawImage(img, 0, 0, w, h);
      img.src = '//:0'; // for image

      img.width = img.height = 1; // for canvas

      return df.resolve(canvas);
    };

    cx = document.createElement('canvas').getContext('2d');

    if ('imageSmoothingQuality' in cx) {
      runNative();
    } else {
      _run();
    }

    return df.promise();
  };

  var drawFileToCanvas = function drawFileToCanvas(file, mW, mH, bg, maxSource) {
    var df, op; // in -> file
    // out <- canvas

    df = $.Deferred();

    if (!URL) {
      return df.reject('support');
    }

    op = imageLoader(URL.createObjectURL(file));
    op.always(function (img) {
      return URL.revokeObjectURL(img.src);
    });
    op.fail(function () {
      return df.reject('not image');
    });
    op.done(function (img) {
      df.always(function () {
        img.src = '//:0';
      });

      if (maxSource && img.width * img.height > maxSource) {
        return df.reject('max source');
      }

      return getExif(file).always(function (exif) {
        var canvas, ctx, dH, dW, orientation, sSize, swap, trns;
        orientation = parseExifOrientation(exif) || 1;
        swap = orientation > 4;
        sSize = swap ? [img.height, img.width] : [img.width, img.height];

        var _fitSize = fitSize(sSize, [mW, mH]);

        var _fitSize2 = _slicedToArray(_fitSize, 2);

        dW = _fitSize2[0];
        dH = _fitSize2[1];
        trns = [[1, 0, 0, 1, 0, 0], [-1, 0, 0, 1, dW, 0], [-1, 0, 0, -1, dW, dH], [1, 0, 0, -1, 0, dH], [0, 1, 1, 0, 0, 0], [0, 1, -1, 0, dW, 0], [0, -1, -1, 0, dW, dH], [0, -1, 1, 0, 0, dH]][orientation - 1];

        if (!trns) {
          return df.reject('bad image');
        }

        canvas = document.createElement('canvas');
        canvas.width = dW;
        canvas.height = dH;
        ctx = canvas.getContext('2d');
        ctx.transform.apply(ctx, trns);

        if (swap) {
          var _ref = [dH, dW];
          dW = _ref[0];
          dH = _ref[1];
        }

        if (bg) {
          ctx.fillStyle = bg;
          ctx.fillRect(0, 0, dW, dH);
        }

        ctx.drawImage(img, 0, 0, dW, dH);
        return df.resolve(canvas, sSize);
      });
    });
    return df.promise();
  }; // Util functions


  var readJpegChunks = function readJpegChunks(file) {
    var df, pos, readNext, readNextChunk, readToView;

    readToView = function readToView(file, cb) {
      var reader;
      reader = new FileReader();

      reader.onload = function () {
        return cb(new DataView(reader.result));
      };

      reader.onerror = function (e) {
        return df.reject('reader', e);
      };

      return reader.readAsArrayBuffer(file);
    };

    readNext = function readNext() {
      return readToView(file.slice(pos, pos + 128), function (view) {
        var i, j, ref;

        for (i = j = 0, ref = view.byteLength; ref >= 0 ? j < ref : j > ref; i = ref >= 0 ? ++j : --j) {
          if (view.getUint8(i) === 0xff) {
            pos += i;
            break;
          }
        }

        return readNextChunk();
      });
    };

    readNextChunk = function readNextChunk() {
      var startPos;
      startPos = pos; // todo fix
      // eslint-disable-next-line no-return-assign

      return readToView(file.slice(pos, pos += 4), function (view) {
        var length, marker;

        if (view.byteLength !== 4 || view.getUint8(0) !== 0xff) {
          return df.reject('corrupted');
        }

        marker = view.getUint8(1);

        if (marker === 0xda) {
          // Start Of Scan
          // console.log('read jpeg chunks: ' + (new Date() - start))
          return df.resolve();
        }

        length = view.getUint16(2) - 2; // eslint-disable-next-line no-return-assign

        return readToView(file.slice(pos, pos += length), function (view) {
          if (view.byteLength !== length) {
            return df.reject('corrupted');
          }

          df.notify(startPos, length, marker, view);
          return readNext();
        });
      });
    };

    df = $.Deferred();

    if (!(FileReader && DataView)) {
      return df.reject('support');
    } // start = new Date()


    pos = 2;
    readToView(file.slice(0, 2), function (view) {
      if (view.getUint16(0) !== 0xffd8) {
        return df.reject('not jpeg');
      }

      return readNext();
    });
    return df.promise();
  };

  var replaceJpegChunk = function replaceJpegChunk(blob, marker, chunks) {
    var df, oldChunkLength, oldChunkPos, op;
    df = $.Deferred();
    oldChunkPos = [];
    oldChunkLength = [];
    op = readJpegChunks(blob);
    op.fail(df.reject);
    op.progress(function (pos, length, oldMarker) {
      if (oldMarker === marker) {
        oldChunkPos.push(pos);
        return oldChunkLength.push(length);
      }
    });
    op.done(function () {
      var chunk, i, intro, j, k, len, newChunks, pos, ref;
      newChunks = [blob.slice(0, 2)];

      for (j = 0, len = chunks.length; j < len; j++) {
        chunk = chunks[j];
        intro = new DataView(new ArrayBuffer(4));
        intro.setUint16(0, 0xff00 + marker);
        intro.setUint16(2, chunk.byteLength + 2);
        newChunks.push(intro.buffer);
        newChunks.push(chunk);
      }

      pos = 2;

      for (i = k = 0, ref = oldChunkPos.length; ref >= 0 ? k < ref : k > ref; i = ref >= 0 ? ++k : --k) {
        if (oldChunkPos[i] > pos) {
          newChunks.push(blob.slice(pos, oldChunkPos[i]));
        }

        pos = oldChunkPos[i] + oldChunkLength[i] + 4;
      }

      newChunks.push(blob.slice(pos, blob.size));
      return df.resolve(new Blob(newChunks, {
        type: blob.type
      }));
    });
    return df.promise();
  };

  var getExif = function getExif(file) {
    var exif, op;
    exif = null;
    op = readJpegChunks(file);
    op.progress(function (pos, l, marker, view) {
      if (!exif && marker === 0xe1) {
        if (view.byteLength >= 14) {
          if (view.getUint32(0) === 0x45786966 && view.getUint16(4) === 0) {
            exif = view;
            return exif;
          }
        }
      }
    });
    return op.then(function () {
      return exif;
    }, function (reason) {
      return $.Deferred().reject(exif, reason);
    });
  };

  var parseExifOrientation = function parseExifOrientation(exif) {
    var count, j, little, offset, ref;

    if (!exif || exif.byteLength < 14 || exif.getUint32(0) !== 0x45786966 || exif.getUint16(4) !== 0) {
      return null;
    }

    if (exif.getUint16(6) === 0x4949) {
      little = true;
    } else if (exif.getUint16(6) === 0x4d4d) {
      little = false;
    } else {
      return null;
    }

    if (exif.getUint16(8, little) !== 0x002a) {
      return null;
    }

    offset = 8 + exif.getUint32(10, little);
    count = exif.getUint16(offset - 2, little);

    for (j = 0, ref = count; ref >= 0 ? j < ref : j > ref; ref >= 0 ? ++j : --j) {
      if (exif.byteLength < offset + 10) {
        return null;
      }

      if (exif.getUint16(offset, little) === 0x0112) {
        return exif.getUint16(offset + 8, little);
      }

      offset += 12;
    }

    return null;
  };

  var hasTransparency = function hasTransparency(img) {
    var canvas, ctx, data, i, j, pcsn, ref;
    pcsn = 50;
    canvas = document.createElement('canvas');
    canvas.width = canvas.height = pcsn;
    ctx = canvas.getContext('2d');
    ctx.drawImage(img, 0, 0, pcsn, pcsn);
    data = ctx.getImageData(0, 0, pcsn, pcsn).data;
    canvas.width = canvas.height = 1;

    for (i = j = 3, ref = data.length; j < ref; i = j += 4) {
      if (data[i] < 254) {
        return true;
      }
    }

    return false;
  };

  // progressState: one of 'error', 'ready', 'uploading', 'uploaded'
  // internal api
  //   __notifyApi: file upload in progress
  //   __resolveApi: file is ready
  //   __rejectApi: file failed on any stage
  //   __completeUpload: file uploaded, info required

  var BaseFile =
  /*#__PURE__*/
  function () {
    function BaseFile(param, settings1) {
      var sourceInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

      _classCallCheck(this, BaseFile);

      var base;
      this.settings = settings1;
      this.sourceInfo = sourceInfo;
      this.fileId = null;
      this.fileName = null;
      this.sanitizedName = null;
      this.fileSize = null;
      this.isStored = null;
      this.cdnUrlModifiers = null;
      this.isImage = null;
      this.imageInfo = null;
      this.mimeType = null;
      this.s3Bucket = null;
      (base = this.sourceInfo).source || (base.source = this.sourceName);

      this.__setupValidation();

      this.__initApi();
    }

    _createClass(BaseFile, [{
      key: "__startUpload",
      value: function __startUpload() {
        return $.Deferred().resolve();
      }
    }, {
      key: "__completeUpload",
      value: function __completeUpload() {
        var _this = this;

        var _check, logger, ncalls, timeout; // Update info until @apiDeferred resolved.


        ncalls = 0;

        if (this.settings.debugUploads) {
          debug('Load file info.', this.fileId, this.settings.publicKey);
          logger = setInterval(function () {
            return debug('Still waiting for file ready.', ncalls, _this.fileId, _this.settings.publicKey);
          }, 5000);
          this.apiDeferred.done(function () {
            return debug('File uploaded.', ncalls, _this.fileId, _this.settings.publicKey);
          }).always(function () {
            return clearInterval(logger);
          });
        }

        timeout = 100;
        return (_check = function check() {
          if (_this.apiDeferred.state() === 'pending') {
            ncalls += 1;
            return _this.__updateInfo().done(function () {
              setTimeout(_check, timeout);
              timeout += 50;
              return timeout;
            });
          }
        })();
      }
    }, {
      key: "__updateInfo",
      value: function __updateInfo() {
        var _this2 = this;

        return jsonp("".concat(this.settings.urlBase, "/info/"), 'GET', {
          jsonerrors: 1,
          file_id: this.fileId,
          pub_key: this.settings.publicKey,
          // Assume that we have all other info if isImage is set to something
          // other than null and we only waiting for is_ready flag.
          wait_is_ready: +(this.isImage === null)
        }, {
          headers: {
            'X-UC-User-Agent': this.settings._userAgent
          }
        }).fail(function (reason) {
          if (_this2.settings.debugUploads) {
            log("Can't load file info. Probably removed.", _this2.fileId, _this2.settings.publicKey, reason);
          }