{"version":3,"sources":["jquery.fileupload.js"],"names":["factory","define","amd","exports","require","window","jQuery","$","getDragHandler","type","isDragOver","e","dataTransfer","originalEvent","inArray","types","this","_trigger","Event","delegatedEvent","preventDefault","dropEffect","parts","support","fileInput","RegExp","test","navigator","userAgent","prop","xhrFileUpload","ProgressEvent","FileReader","xhrFormDataFileUpload","FormData","blobSlice","Blob","prototype","slice","webkitSlice","mozSlice","widget","options","dropZone","document","pasteZone","undefined","replaceFileInput","paramName","singleFileUploads","limitMultiFileUploads","limitMultiFileUploadSize","limitMultiFileUploadSizeOverhead","sequentialUploads","limitConcurrentUploads","forceIframeTransport","redirect","redirectParamName","postMessage","multipart","maxChunkSize","uploadedBytes","recalculateProgress","progressInterval","bitrateInterval","autoUpload","uniqueFilenames","messages","i18n","message","context","toString","each","key","value","replace","formData","form","serializeArray","add","data","isDefaultPrevented","fileupload","process","done","submit","processData","contentType","cache","timeout","_promisePipe","fn","jquery","split","Number","_specialOptions","_blobSlice","apply","arguments","_BitrateTimer","timestamp","Date","now","getTime","loaded","bitrate","getBitrate","interval","timeDiff","_isXHRUpload","_getFormData","isArray","name","push","_getTotal","files","total","index","file","size","_initProgressObject","obj","progress","_progress","extend","_initResponseObject","_response","Object","hasOwnProperty","call","_onProgress","lengthComputable","_time","Math","floor","chunkSize","_bitrateTimer","_initProgressListener","that","xhr","ajaxSettings","upload","on","oe","_deinitProgressListener","off","_isInstanceOf","_getUniqueFilename","map","String","_","p1","p2","_initXHRData","headers","contentRange","blob","encodeURI","uploadName","field","append","fileName","_initIframeSettings","targetHost","url","dataType","location","host","_initDataSettings","_chunkedUpload","_getParamName","input","i","length","_initFormSettings","href","toUpperCase","formAcceptCharset","attr","_getAJAXSettings","_getDeferredState","deferred","state","isResolved","isRejected","_enhancePromise","promise","success","error","fail","complete","always","_getXHRPromise","resolveOrReject","args","dfd","Deferred","resolveWith","rejectWith","abort","_addConvenienceMethods","getPromise","resolveFunc","rejectFunc","_processQueue","errorThrown","jqXHR","_onSend","processing","response","_getUploadedBytes","range","getResponseHeader","upperBytesPos","parseInt","testOnly","fs","ub","mcs","o","currentLoaded","ajax","result","textStatus","_beforeSend","_active","_onDone","_onFail","_onAlways","jqXHRorResult","jqXHRorError","aborted","slot","pipe","send","_sending","nextSlot","_slots","shift","resolve","_sequence","_onAdd","paramNameSet","paramNameSlice","fileSet","filesLength","limit","limitSize","overhead","batchSize","j","originalFiles","element","newData","_replaceFileInput","inputClone","clone","restoreFocus","is","activeElement","fileInputClone","reset","after","detach","trigger","cleanData","el","_handleFileTreeEntry","entry","path","dirReader","entries","errorHandler","readEntries","results","concat","_handleFileTreeEntries","successHandler","isFile","_file","relativePath","isDirectory","createReader","when","Array","_getDroppedFiles","items","webkitGetAsEntry","getAsEntry","item","getAsFile","makeArray","_getSingleFileInputFiles","fileSize","_getFileInputFiles","_onChange","target","_onPaste","clipboardData","_onDrop","_onDragOver","_onDragEnter","_onDragLeave","_initEventHandlers","_on","dragover","drop","dragenter","dragleave","paste","change","_destroyEventHandlers","_off","_destroy","_setOption","reinit","_super","_initSpecialOptions","find","_getRegExp","str","modifiers","pop","join","_isRegExpOption","_initDataAttributes","attributes","toLowerCase","charAt","_create","active","disabled","reject","then"],"mappings":"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","file":"jquery.fileupload.js","sourcesContent":["/*\n * jQuery File Upload Plugin\n * https://github.com/blueimp/jQuery-File-Upload\n *\n * Copyright 2010, Sebastian Tschan\n * https://blueimp.net\n *\n * Licensed under the MIT license:\n * https://opensource.org/licenses/MIT\n */\n\n/* global define, require */\n/* eslint-disable new-cap */\n\n(function (factory) {\n  'use strict';\n  if (typeof define === 'function' && define.amd) {\n    // Register as an anonymous AMD module:\n    define(['jquery', 'jquery-ui/ui/widget'], factory);\n  } else if (typeof exports === 'object') {\n    // Node/CommonJS:\n    factory(require('jquery'), require('./vendor/jquery.ui.widget'));\n  } else {\n    // Browser globals:\n    factory(window.jQuery);\n  }\n})(function ($) {\n  'use strict';\n\n  // Detect file input support, based on\n  // https://viljamis.com/2012/file-upload-support-on-mobile/\n  $.support.fileInput = !(\n    new RegExp(\n      // Handle devices which give false positives for the feature detection:\n      '(Android (1\\\\.[0156]|2\\\\.[01]))' +\n        '|(Windows Phone (OS 7|8\\\\.0))|(XBLWP)|(ZuneWP)|(WPDesktop)' +\n        '|(w(eb)?OSBrowser)|(webOS)' +\n        '|(Kindle/(1\\\\.0|2\\\\.[05]|3\\\\.0))'\n    ).test(window.navigator.userAgent) ||\n    // Feature detection for all other devices:\n    $('<input type=\"file\"/>').prop('disabled')\n  );\n\n  // The FileReader API is not actually used, but works as feature detection,\n  // as some Safari versions (5?) support XHR file uploads via the FormData API,\n  // but not non-multipart XHR file uploads.\n  // window.XMLHttpRequestUpload is not available on IE10, so we check for\n  // window.ProgressEvent instead to detect XHR2 file upload capability:\n  $.support.xhrFileUpload = !!(window.ProgressEvent && window.FileReader);\n  $.support.xhrFormDataFileUpload = !!window.FormData;\n\n  // Detect support for Blob slicing (required for chunked uploads):\n  $.support.blobSlice =\n    window.Blob &&\n    (Blob.prototype.slice ||\n      Blob.prototype.webkitSlice ||\n      Blob.prototype.mozSlice);\n\n  /**\n   * Helper function to create drag handlers for dragover/dragenter/dragleave\n   *\n   * @param {string} type Event type\n   * @returns {Function} Drag handler\n   */\n  function getDragHandler(type) {\n    var isDragOver = type === 'dragover';\n    return function (e) {\n      e.dataTransfer = e.originalEvent && e.originalEvent.dataTransfer;\n      var dataTransfer = e.dataTransfer;\n      if (\n        dataTransfer &&\n        $.inArray('Files', dataTransfer.types) !== -1 &&\n        this._trigger(type, $.Event(type, { delegatedEvent: e })) !== false\n      ) {\n        e.preventDefault();\n        if (isDragOver) {\n          dataTransfer.dropEffect = 'copy';\n        }\n      }\n    };\n  }\n\n  // The fileupload widget listens for change events on file input fields defined\n  // via fileInput setting and paste or drop events of the given dropZone.\n  // In addition to the default jQuery Widget methods, the fileupload widget\n  // exposes the \"add\" and \"send\" methods, to add or directly send files using\n  // the fileupload API.\n  // By default, files added via file input selection, paste, drag & drop or\n  // \"add\" method are uploaded immediately, but it is possible to override\n  // the \"add\" callback option to queue file uploads.\n  $.widget('blueimp.fileupload', {\n    options: {\n      // The drop target element(s), by the default the complete document.\n      // Set to null to disable drag & drop support:\n      dropZone: $(document),\n      // The paste target element(s), by the default undefined.\n      // Set to a DOM node or jQuery object to enable file pasting:\n      pasteZone: undefined,\n      // The file input field(s), that are listened to for change events.\n      // If undefined, it is set to the file input fields inside\n      // of the widget element on plugin initialization.\n      // Set to null to disable the change listener.\n      fileInput: undefined,\n      // By default, the file input field is replaced with a clone after\n      // each input field change event. This is required for iframe transport\n      // queues and allows change events to be fired for the same file\n      // selection, but can be disabled by setting the following option to false:\n      replaceFileInput: true,\n      // The parameter name for the file form data (the request argument name).\n      // If undefined or empty, the name property of the file input field is\n      // used, or \"files[]\" if the file input name property is also empty,\n      // can be a string or an array of strings:\n      paramName: undefined,\n      // By default, each file of a selection is uploaded using an individual\n      // request for XHR type uploads. Set to false to upload file\n      // selections in one request each:\n      singleFileUploads: true,\n      // To limit the number of files uploaded with one XHR request,\n      // set the following option to an integer greater than 0:\n      limitMultiFileUploads: undefined,\n      // The following option limits the number of files uploaded with one\n      // XHR request to keep the request size under or equal to the defined\n      // limit in bytes:\n      limitMultiFileUploadSize: undefined,\n      // Multipart file uploads add a number of bytes to each uploaded file,\n      // therefore the following option adds an overhead for each file used\n      // in the limitMultiFileUploadSize configuration:\n      limitMultiFileUploadSizeOverhead: 512,\n      // Set the following option to true to issue all file upload requests\n      // in a sequential order:\n      sequentialUploads: false,\n      // To limit the number of concurrent uploads,\n      // set the following option to an integer greater than 0:\n      limitConcurrentUploads: undefined,\n      // Set the following option to true to force iframe transport uploads:\n      forceIframeTransport: false,\n      // Set the following option to the location of a redirect url on the\n      // origin server, for cross-domain iframe transport uploads:\n      redirect: undefined,\n      // The parameter name for the redirect url, sent as part of the form\n      // data and set to 'redirect' if this option is empty:\n      redirectParamName: undefined,\n      // Set the following option to the location of a postMessage window,\n      // to enable postMessage transport uploads:\n      postMessage: undefined,\n      // By default, XHR file uploads are sent as multipart/form-data.\n      // The iframe transport is always using multipart/form-data.\n      // Set to false to enable non-multipart XHR uploads:\n      multipart: true,\n      // To upload large files in smaller chunks, set the following option\n      // to a preferred maximum chunk size. If set to 0, null or undefined,\n      // or the browser does not support the required Blob API, files will\n      // be uploaded as a whole.\n      maxChunkSize: undefined,\n      // When a non-multipart upload or a chunked multipart upload has been\n      // aborted, this option can be used to resume the upload by setting\n      // it to the size of the already uploaded bytes. This option is most\n      // useful when modifying the options object inside of the \"add\" or\n      // \"send\" callbacks, as the options are cloned for each file upload.\n      uploadedBytes: undefined,\n      // By default, failed (abort or error) file uploads are removed from the\n      // global progress calculation. Set the following option to false to\n      // prevent recalculating the global progress data:\n      recalculateProgress: true,\n      // Interval in milliseconds to calculate and trigger progress events:\n      progressInterval: 100,\n      // Interval in milliseconds to calculate progress bitrate:\n      bitrateInterval: 500,\n      // By default, uploads are started automatically when adding files:\n      autoUpload: true,\n      // By default, duplicate file names are expected to be handled on\n      // the server-side. If this is not possible (e.g. when uploading\n      // files directly to Amazon S3), the following option can be set to\n      // an empty object or an object mapping existing filenames, e.g.:\n      // { \"image.jpg\": true, \"image (1).jpg\": true }\n      // If it is set, all files will be uploaded with unique filenames,\n      // adding increasing number suffixes if necessary, e.g.:\n      // \"image (2).jpg\"\n      uniqueFilenames: undefined,\n\n      // Error and info messages:\n      messages: {\n        uploadedBytes: 'Uploaded bytes exceed file size'\n      },\n\n      // Translation function, gets the message key to be translated\n      // and an object with context specific data as arguments:\n      i18n: function (message, context) {\n        // eslint-disable-next-line no-param-reassign\n        message = this.messages[message] || message.toString();\n        if (context) {\n          $.each(context, function (key, value) {\n            // eslint-disable-next-line no-param-reassign\n            message = message.replace('{' + key + '}', value);\n          });\n        }\n        return message;\n      },\n\n      // Additional form data to be sent along with the file uploads can be set\n      // using this option, which accepts an array of objects with name and\n      // value properties, a function returning such an array, a FormData\n      // object (for XHR file uploads), or a simple object.\n      // The form of the first fileInput is given as parameter to the function:\n      formData: function (form) {\n        return form.serializeArray();\n      },\n\n      // The add callback is invoked as soon as files are added to the fileupload\n      // widget (via file input selection, drag & drop, paste or add API call).\n      // If the singleFileUploads option is enabled, this callback will be\n      // called once for each file in the selection for XHR file uploads, else\n      // once for each file selection.\n      //\n      // The upload starts when the submit method is invoked on the data parameter.\n      // The data object contains a files property holding the added files\n      // and allows you to override plugin options as well as define ajax settings.\n      //\n      // Listeners for this callback can also be bound the following way:\n      // .on('fileuploadadd', func);\n      //\n      // data.submit() returns a Promise object and allows to attach additional\n      // handlers using jQuery's Deferred callbacks:\n      // data.submit().done(func).fail(func).always(func);\n      add: function (e, data) {\n        if (e.isDefaultPrevented()) {\n          return false;\n        }\n        if (\n          data.autoUpload ||\n          (data.autoUpload !== false &&\n            $(this).fileupload('option', 'autoUpload'))\n        ) {\n          data.process().done(function () {\n            data.submit();\n          });\n        }\n      },\n\n      // Other callbacks:\n\n      // Callback for the submit event of each file upload:\n      // submit: function (e, data) {}, // .on('fileuploadsubmit', func);\n\n      // Callback for the start of each file upload request:\n      // send: function (e, data) {}, // .on('fileuploadsend', func);\n\n      // Callback for successful uploads:\n      // done: function (e, data) {}, // .on('fileuploaddone', func);\n\n      // Callback for failed (abort or error) uploads:\n      // fail: function (e, data) {}, // .on('fileuploadfail', func);\n\n      // Callback for completed (success, abort or error) requests:\n      // always: function (e, data) {}, // .on('fileuploadalways', func);\n\n      // Callback for upload progress events:\n      // progress: function (e, data) {}, // .on('fileuploadprogress', func);\n\n      // Callback for global upload progress events:\n      // progressall: function (e, data) {}, // .on('fileuploadprogressall', func);\n\n      // Callback for uploads start, equivalent to the global ajaxStart event:\n      // start: function (e) {}, // .on('fileuploadstart', func);\n\n      // Callback for uploads stop, equivalent to the global ajaxStop event:\n      // stop: function (e) {}, // .on('fileuploadstop', func);\n\n      // Callback for change events of the fileInput(s):\n      // change: function (e, data) {}, // .on('fileuploadchange', func);\n\n      // Callback for paste events to the pasteZone(s):\n      // paste: function (e, data) {}, // .on('fileuploadpaste', func);\n\n      // Callback for drop events of the dropZone(s):\n      // drop: function (e, data) {}, // .on('fileuploaddrop', func);\n\n      // Callback for dragover events of the dropZone(s):\n      // dragover: function (e) {}, // .on('fileuploaddragover', func);\n\n      // Callback before the start of each chunk upload request (before form data initialization):\n      // chunkbeforesend: function (e, data) {}, // .on('fileuploadchunkbeforesend', func);\n\n      // Callback for the start of each chunk upload request:\n      // chunksend: function (e, data) {}, // .on('fileuploadchunksend', func);\n\n      // Callback for successful chunk uploads:\n      // chunkdone: function (e, data) {}, // .on('fileuploadchunkdone', func);\n\n      // Callback for failed (abort or error) chunk uploads:\n      // chunkfail: function (e, data) {}, // .on('fileuploadchunkfail', func);\n\n      // Callback for completed (success, abort or error) chunk upload requests:\n      // chunkalways: function (e, data) {}, // .on('fileuploadchunkalways', func);\n\n      // The plugin options are used as settings object for the ajax calls.\n      // The following are jQuery ajax settings required for the file uploads:\n      processData: false,\n      contentType: false,\n      cache: false,\n      timeout: 0\n    },\n\n    // jQuery versions before 1.8 require promise.pipe if the return value is\n    // used, as promise.then in older versions has a different behavior, see:\n    // https://blog.jquery.com/2012/08/09/jquery-1-8-released/\n    // https://bugs.jquery.com/ticket/11010\n    // https://github.com/blueimp/jQuery-File-Upload/pull/3435\n    _promisePipe: (function () {\n      var parts = $.fn.jquery.split('.');\n      return Number(parts[0]) > 1 || Number(parts[1]) > 7 ? 'then' : 'pipe';\n    })(),\n\n    // A list of options that require reinitializing event listeners and/or\n    // special initialization code:\n    _specialOptions: [\n      'fileInput',\n      'dropZone',\n      'pasteZone',\n      'multipart',\n      'forceIframeTransport'\n    ],\n\n    _blobSlice:\n      $.support.blobSlice &&\n      function () {\n        var slice = this.slice || this.webkitSlice || this.mozSlice;\n        return slice.apply(this, arguments);\n      },\n\n    _BitrateTimer: function () {\n      this.timestamp = Date.now ? Date.now() : new Date().getTime();\n      this.loaded = 0;\n      this.bitrate = 0;\n      this.getBitrate = function (now, loaded, interval) {\n        var timeDiff = now - this.timestamp;\n        if (!this.bitrate || !interval || timeDiff > interval) {\n          this.bitrate = (loaded - this.loaded) * (1000 / timeDiff) * 8;\n          this.loaded = loaded;\n          this.timestamp = now;\n        }\n        return this.bitrate;\n      };\n    },\n\n    _isXHRUpload: function (options) {\n      return (\n        !options.forceIframeTransport &&\n        ((!options.multipart && $.support.xhrFileUpload) ||\n          $.support.xhrFormDataFileUpload)\n      );\n    },\n\n    _getFormData: function (options) {\n      var formData;\n      if ($.type(options.formData) === 'function') {\n        return options.formData(options.form);\n      }\n      if ($.isArray(options.formData)) {\n        return options.formData;\n      }\n      if ($.type(options.formData) === 'object') {\n        formData = [];\n        $.each(options.formData, function (name, value) {\n          formData.push({ name: name, value: value });\n        });\n        return formData;\n      }\n      return [];\n    },\n\n    _getTotal: function (files) {\n      var total = 0;\n      $.each(files, function (index, file) {\n        total += file.size || 1;\n      });\n      return total;\n    },\n\n    _initProgressObject: function (obj) {\n      var progress = {\n        loaded: 0,\n        total: 0,\n        bitrate: 0\n      };\n      if (obj._progress) {\n        $.extend(obj._progress, progress);\n      } else {\n        obj._progress = progress;\n      }\n    },\n\n    _initResponseObject: function (obj) {\n      var prop;\n      if (obj._response) {\n        for (prop in obj._response) {\n          if (Object.prototype.hasOwnProperty.call(obj._response, prop)) {\n            delete obj._response[prop];\n          }\n        }\n      } else {\n        obj._response = {};\n      }\n    },\n\n    _onProgress: function (e, data) {\n      if (e.lengthComputable) {\n        var now = Date.now ? Date.now() : new Date().getTime(),\n          loaded;\n        if (\n          data._time &&\n          data.progressInterval &&\n          now - data._time < data.progressInterval &&\n          e.loaded !== e.total\n        ) {\n          return;\n        }\n        data._time = now;\n        loaded =\n          Math.floor(\n            (e.loaded / e.total) * (data.chunkSize || data._progress.total)\n          ) + (data.uploadedBytes || 0);\n        // Add the difference from the previously loaded state\n        // to the global loaded counter:\n        this._progress.loaded += loaded - data._progress.loaded;\n        this._progress.bitrate = this._bitrateTimer.getBitrate(\n          now,\n          this._progress.loaded,\n          data.bitrateInterval\n        );\n        data._progress.loaded = data.loaded = loaded;\n        data._progress.bitrate = data.bitrate = data._bitrateTimer.getBitrate(\n          now,\n          loaded,\n          data.bitrateInterval\n        );\n        // Trigger a custom progress event with a total data property set\n        // to the file size(s) of the current upload and a loaded data\n        // property calculated accordingly:\n        this._trigger(\n          'progress',\n          $.Event('progress', { delegatedEvent: e }),\n          data\n        );\n        // Trigger a global progress event for all current file uploads,\n        // including ajax calls queued for sequential file uploads:\n        this._trigger(\n          'progressall',\n          $.Event('progressall', { delegatedEvent: e }),\n          this._progress\n        );\n      }\n    },\n\n    _initProgressListener: function (options) {\n      var that = this,\n        xhr = options.xhr ? options.xhr() : $.ajaxSettings.xhr();\n      // Accesss to the native XHR object is required to add event listeners\n      // for the upload progress event:\n      if (xhr.upload) {\n        $(xhr.upload).on('progress', function (e) {\n          var oe = e.originalEvent;\n          // Make sure the progress event properties get copied over:\n          e.lengthComputable = oe.lengthComputable;\n          e.loaded = oe.loaded;\n          e.total = oe.total;\n          that._onProgress(e, options);\n        });\n        options.xhr = function () {\n          return xhr;\n        };\n      }\n    },\n\n    _deinitProgressListener: function (options) {\n      var xhr = options.xhr ? options.xhr() : $.ajaxSettings.xhr();\n      if (xhr.upload) {\n        $(xhr.upload).off('progress');\n      }\n    },\n\n    _isInstanceOf: function (type, obj) {\n      // Cross-frame instanceof check\n      return Object.prototype.toString.call(obj) === '[object ' + type + ']';\n    },\n\n    _getUniqueFilename: function (name, map) {\n      // eslint-disable-next-line no-param-reassign\n      name = String(name);\n      if (map[name]) {\n        // eslint-disable-next-line no-param-reassign\n        name = name.replace(/(?: \\(([\\d]+)\\))?(\\.[^.]+)?$/, function (\n          _,\n          p1,\n          p2\n        ) {\n          var index = p1 ? Number(p1) + 1 : 1;\n          var ext = p2 || '';\n          return ' (' + index + ')' + ext;\n        });\n        return this._getUniqueFilename(name, map);\n      }\n      map[name] = true;\n      return name;\n    },\n\n    _initXHRData: function (options) {\n      var that = this,\n        formData,\n        file = options.files[0],\n        // Ignore non-multipart setting if not supported:\n        multipart = options.multipart || !$.support.xhrFileUpload,\n        paramName =\n          $.type(options.paramName) === 'array'\n            ? options.paramName[0]\n            : options.paramName;\n      options.headers = $.extend({}, options.headers);\n      if (options.contentRange) {\n        options.headers['Content-Range'] = options.contentRange;\n      }\n      if (!multipart || options.blob || !this._isInstanceOf('File', file)) {\n        options.headers['Content-Disposition'] =\n          'attachment; filename=\"' +\n          encodeURI(file.uploadName || file.name) +\n          '\"';\n      }\n      if (!multipart) {\n        options.contentType = file.type || 'application/octet-stream';\n        options.data = options.blob || file;\n      } else if ($.support.xhrFormDataFileUpload) {\n        if (options.postMessage) {\n          // window.postMessage does not allow sending FormData\n          // objects, so we just add the File/Blob objects to\n          // the formData array and let the postMessage window\n          // create the FormData object out of this array:\n          formData = this._getFormData(options);\n          if (options.blob) {\n            formData.push({\n              name: paramName,\n              value: options.blob\n            });\n          } else {\n            $.each(options.files, function (index, file) {\n              formData.push({\n                name:\n                  ($.type(options.paramName) === 'array' &&\n                    options.paramName[index]) ||\n                  paramName,\n                value: file\n              });\n            });\n          }\n        } else {\n          if (that._isInstanceOf('FormData', options.formData)) {\n            formData = options.formData;\n          } else {\n            formData = new FormData();\n            $.each(this._getFormData(options), function (index, field) {\n              formData.append(field.name, field.value);\n            });\n          }\n          if (options.blob) {\n            formData.append(\n              paramName,\n              options.blob,\n              file.uploadName || file.name\n            );\n          } else {\n            $.each(options.files, function (index, file) {\n              // This check allows the tests to run with\n              // dummy objects:\n              if (\n                that._isInstanceOf('File', file) ||\n                that._isInstanceOf('Blob', file)\n              ) {\n                var fileName = file.uploadName || file.name;\n                if (options.uniqueFilenames) {\n                  fileName = that._getUniqueFilename(\n                    fileName,\n                    options.uniqueFilenames\n                  );\n                }\n                formData.append(\n                  ($.type(options.paramName) === 'array' &&\n                    options.paramName[index]) ||\n                    paramName,\n                  file,\n                  fileName\n                );\n              }\n            });\n          }\n        }\n        options.data = formData;\n      }\n      // Blob reference is not needed anymore, free memory:\n      options.blob = null;\n    },\n\n    _initIframeSettings: function (options) {\n      var targetHost = $('<a></a>').prop('href', options.url).prop('host');\n      // Setting the dataType to iframe enables the iframe transport:\n      options.dataType = 'iframe ' + (options.dataType || '');\n      // The iframe transport accepts a serialized array as form data:\n      options.formData = this._getFormData(options);\n      // Add redirect url to form data on cross-domain uploads:\n      if (options.redirect && targetHost && targetHost !== location.host) {\n        options.formData.push({\n          name: options.redirectParamName || 'redirect',\n          value: options.redirect\n        });\n      }\n    },\n\n    _initDataSettings: function (options) {\n      if (this._isXHRUpload(options)) {\n        if (!this._chunkedUpload(options, true)) {\n          if (!options.data) {\n            this._initXHRData(options);\n          }\n          this._initProgressListener(options);\n        }\n        if (options.postMessage) {\n          // Setting the dataType to postmessage enables the\n          // postMessage transport:\n          options.dataType = 'postmessage ' + (options.dataType || '');\n        }\n      } else {\n        this._initIframeSettings(options);\n      }\n    },\n\n    _getParamName: function (options) {\n      var fileInput = $(options.fileInput),\n        paramName = options.paramName;\n      if (!paramName) {\n        paramName = [];\n        fileInput.each(function () {\n          var input = $(this),\n            name = input.prop('name') || 'files[]',\n            i = (input.prop('files') || [1]).length;\n          while (i) {\n            paramName.push(name);\n            i -= 1;\n          }\n        });\n        if (!paramName.length) {\n          paramName = [fileInput.prop('name') || 'files[]'];\n        }\n      } else if (!$.isArray(paramName)) {\n        paramName = [paramName];\n      }\n      return paramName;\n    },\n\n    _initFormSettings: function (options) {\n      // Retrieve missing options from the input field and the\n      // associated form, if available:\n      if (!options.form || !options.form.length) {\n        options.form = $(options.fileInput.prop('form'));\n        // If the given file input doesn't have an associated form,\n        // use the default widget file input's form:\n        if (!options.form.length) {\n          options.form = $(this.options.fileInput.prop('form'));\n        }\n      }\n      options.paramName = this._getParamName(options);\n      if (!options.url) {\n        options.url = options.form.prop('action') || location.href;\n      }\n      // The HTTP request method must be \"POST\" or \"PUT\":\n      options.type = (\n        options.type ||\n        ($.type(options.form.prop('method')) === 'string' &&\n          options.form.prop('method')) ||\n        ''\n      ).toUpperCase();\n      if (\n        options.type !== 'POST' &&\n        options.type !== 'PUT' &&\n        options.type !== 'PATCH'\n      ) {\n        options.type = 'POST';\n      }\n      if (!options.formAcceptCharset) {\n        options.formAcceptCharset = options.form.attr('accept-charset');\n      }\n    },\n\n    _getAJAXSettings: function (data) {\n      var options = $.extend({}, this.options, data);\n      this._initFormSettings(options);\n      this._initDataSettings(options);\n      return options;\n    },\n\n    // jQuery 1.6 doesn't provide .state(),\n    // while jQuery 1.8+ removed .isRejected() and .isResolved():\n    _getDeferredState: function (deferred) {\n      if (deferred.state) {\n        return deferred.state();\n      }\n      if (deferred.isResolved()) {\n        return 'resolved';\n      }\n      if (deferred.isRejected()) {\n        return 'rejected';\n      }\n      return 'pending';\n    },\n\n    // Maps jqXHR callbacks to the equivalent\n    // methods of the given Promise object:\n    _enhancePromise: function (promise) {\n      promise.success = promise.done;\n      promise.error = promise.fail;\n      promise.complete = promise.always;\n      return promise;\n    },\n\n    // Creates and returns a Promise object enhanced with\n    // the jqXHR methods abort, success, error and complete:\n    _getXHRPromise: function (resolveOrReject, context, args) {\n      var dfd = $.Deferred(),\n        promise = dfd.promise();\n      // eslint-disable-next-line no-param-reassign\n      context = context || this.options.context || promise;\n      if (resolveOrReject === true) {\n        dfd.resolveWith(context, args);\n      } else if (resolveOrReject === false) {\n        dfd.rejectWith(context, args);\n      }\n      promise.abort = dfd.promise;\n      return this._enhancePromise(promise);\n    },\n\n    // Adds convenience methods to the data callback argument:\n    _addConvenienceMethods: function (e, data) {\n      var that = this,\n        getPromise = function (args) {\n          return $.Deferred().resolveWith(that, args).promise();\n        };\n      data.process = function (resolveFunc, rejectFunc) {\n        if (resolveFunc || rejectFunc) {\n          data._processQueue = this._processQueue = (this._processQueue ||\n            getPromise([this]))\n            [that._promisePipe](function () {\n              if (data.errorThrown) {\n                return $.Deferred().rejectWith(that, [data]).promise();\n              }\n              return getPromise(arguments);\n            })\n            [that._promisePipe](resolveFunc, rejectFunc);\n        }\n        return this._processQueue || getPromise([this]);\n      };\n      data.submit = function () {\n        if (this.state() !== 'pending') {\n          data.jqXHR = this.jqXHR =\n            that._trigger(\n              'submit',\n              $.Event('submit', { delegatedEvent: e }),\n              this\n            ) !== false && that._onSend(e, this);\n        }\n        return this.jqXHR || that._getXHRPromise();\n      };\n      data.abort = function () {\n        if (this.jqXHR) {\n          return this.jqXHR.abort();\n        }\n        this.errorThrown = 'abort';\n        that._trigger('fail', null, this);\n        return that._getXHRPromise(false);\n      };\n      data.state = function () {\n        if (this.jqXHR) {\n          return that._getDeferredState(this.jqXHR);\n        }\n        if (this._processQueue) {\n          return that._getDeferredState(this._processQueue);\n        }\n      };\n      data.processing = function () {\n        return (\n          !this.jqXHR &&\n          this._processQueue &&\n          that._getDeferredState(this._processQueue) === 'pending'\n        );\n      };\n      data.progress = function () {\n        return this._progress;\n      };\n      data.response = function () {\n        return this._response;\n      };\n    },\n\n    // Parses the Range header from the server response\n    // and returns the uploaded bytes:\n    _getUploadedBytes: function (jqXHR) {\n      var range = jqXHR.getResponseHeader('Range'),\n        parts = range && range.split('-'),\n        upperBytesPos = parts && parts.length > 1 && parseInt(parts[1], 10);\n      return upperBytesPos && upperBytesPos + 1;\n    },\n\n    // Uploads a file in multiple, sequential requests\n    // by splitting the file up in multiple blob chunks.\n    // If the second parameter is true, only tests if the file\n    // should be uploaded in chunks, but does not invoke any\n    // upload requests:\n    _chunkedUpload: function (options, testOnly) {\n      options.uploadedBytes = options.uploadedBytes || 0;\n      var that = this,\n        file = options.files[0],\n        fs = file.size,\n        ub = options.uploadedBytes,\n        mcs = options.maxChunkSize || fs,\n        slice = this._blobSlice,\n        dfd = $.Deferred(),\n        promise = dfd.promise(),\n        jqXHR,\n        upload;\n      if (\n        !(\n          this._isXHRUpload(options) &&\n          slice &&\n          (ub || ($.type(mcs) === 'function' ? mcs(options) : mcs) < fs)\n        ) ||\n        options.data\n      ) {\n        return false;\n      }\n      if (testOnly) {\n        return true;\n      }\n      if (ub >= fs) {\n        file.error = options.i18n('uploadedBytes');\n        return this._getXHRPromise(false, options.context, [\n          null,\n          'error',\n          file.error\n        ]);\n      }\n      // The chunk upload method:\n      upload = function () {\n        // Clone the options object for each chunk upload:\n        var o = $.extend({}, options),\n          currentLoaded = o._progress.loaded;\n        o.blob = slice.call(\n          file,\n          ub,\n          ub + ($.type(mcs) === 'function' ? mcs(o) : mcs),\n          file.type\n        );\n        // Store the current chunk size, as the blob itself\n        // will be dereferenced after data processing:\n        o.chunkSize = o.blob.size;\n        // Expose the chunk bytes position range:\n        o.contentRange =\n          'bytes ' + ub + '-' + (ub + o.chunkSize - 1) + '/' + fs;\n        // Trigger chunkbeforesend to allow form data to be updated for this chunk\n        that._trigger('chunkbeforesend', null, o);\n        // Process the upload data (the blob and potential form data):\n        that._initXHRData(o);\n        // Add progress listeners for this chunk upload:\n        that._initProgressListener(o);\n        jqXHR = (\n          (that._trigger('chunksend', null, o) !== false && $.ajax(o)) ||\n          that._getXHRPromise(false, o.context)\n        )\n          .done(function (result, textStatus, jqXHR) {\n            ub = that._getUploadedBytes(jqXHR) || ub + o.chunkSize;\n            // Create a progress event if no final progress event\n            // with loaded equaling total has been triggered\n            // for this chunk:\n            if (currentLoaded + o.chunkSize - o._progress.loaded) {\n              that._onProgress(\n                $.Event('progress', {\n                  lengthComputable: true,\n                  loaded: ub - o.uploadedBytes,\n                  total: ub - o.uploadedBytes\n                }),\n                o\n              );\n            }\n            options.uploadedBytes = o.uploadedBytes = ub;\n            o.result = result;\n            o.textStatus = textStatus;\n            o.jqXHR = jqXHR;\n            that._trigger('chunkdone', null, o);\n            that._trigger('chunkalways', null, o);\n            if (ub < fs) {\n              // File upload not yet complete,\n              // continue with the next chunk:\n              upload();\n            } else {\n              dfd.resolveWith(o.context, [result, textStatus, jqXHR]);\n            }\n          })\n          .fail(function (jqXHR, textStatus, errorThrown) {\n            o.jqXHR = jqXHR;\n            o.textStatus = textStatus;\n            o.errorThrown = errorThrown;\n            that._trigger('chunkfail', null, o);\n            that._trigger('chunkalways', null, o);\n            dfd.rejectWith(o.context, [jqXHR, textStatus, errorThrown]);\n          })\n          .always(function () {\n            that._deinitProgressListener(o);\n          });\n      };\n      this._enhancePromise(promise);\n      promise.abort = function () {\n        return jqXHR.abort();\n      };\n      upload();\n      return promise;\n    },\n\n    _beforeSend: function (e, data) {\n      if (this._active === 0) {\n        // the start callback is triggered when an upload starts\n        // and no other uploads are currently running,\n        // equivalent to the global ajaxStart event:\n        this._trigger('start');\n        // Set timer for global bitrate progress calculation:\n        this._bitrateTimer = new this._BitrateTimer();\n        // Reset the global progress values:\n        this._progress.loaded = this._progress.total = 0;\n        this._progress.bitrate = 0;\n      }\n      // Make sure the container objects for the .response() and\n      // .progress() methods on the data object are available\n      // and reset to their initial state:\n      this._initResponseObject(data);\n      this._initProgressObject(data);\n      data._progress.loaded = data.loaded = data.uploadedBytes || 0;\n      data._progress.total = data.total = this._getTotal(data.files) || 1;\n      data._progress.bitrate = data.bitrate = 0;\n      this._active += 1;\n      // Initialize the global progress values:\n      this._progress.loaded += data.loaded;\n      this._progress.total += data.total;\n    },\n\n    _onDone: function (result, textStatus, jqXHR, options) {\n      var total = options._progress.total,\n        response = options._response;\n      if (options._progress.loaded < total) {\n        // Create a progress event if no final progress event\n        // with loaded equaling total has been triggered:\n        this._onProgress(\n          $.Event('progress', {\n            lengthComputable: true,\n            loaded: total,\n            total: total\n          }),\n          options\n        );\n      }\n      response.result = options.result = result;\n      response.textStatus = options.textStatus = textStatus;\n      response.jqXHR = options.jqXHR = jqXHR;\n      this._trigger('done', null, options);\n    },\n\n    _onFail: function (jqXHR, textStatus, errorThrown, options) {\n      var response = options._response;\n      if (options.recalculateProgress) {\n        // Remove the failed (error or abort) file upload from\n        // the global progress calculation:\n        this._progress.loaded -= options._progress.loaded;\n        this._progress.total -= options._progress.total;\n      }\n      response.jqXHR = options.jqXHR = jqXHR;\n      response.textStatus = options.textStatus = textStatus;\n      response.errorThrown = options.errorThrown = errorThrown;\n      this._trigger('fail', null, options);\n    },\n\n    _onAlways: function (jqXHRorResult, textStatus, jqXHRorError, options) {\n      // jqXHRorResult, textStatus and jqXHRorError are added to the\n      // options object via done and fail callbacks\n      this._trigger('always', null, options);\n    },\n\n    _onSend: function (e, data) {\n      if (!data.submit) {\n        this._addConvenienceMethods(e, data);\n      }\n      var that = this,\n        jqXHR,\n        aborted,\n        slot,\n        pipe,\n        options = that._getAJAXSettings(data),\n        send = function () {\n          that._sending += 1;\n          // Set timer for bitrate progress calculation:\n          options._bitrateTimer = new that._BitrateTimer();\n          jqXHR =\n            jqXHR ||\n            (\n              ((aborted ||\n                that._trigger(\n                  'send',\n                  $.Event('send', { delegatedEvent: e }),\n                  options\n                ) === false) &&\n                that._getXHRPromise(false, options.context, aborted)) ||\n              that._chunkedUpload(options) ||\n              $.ajax(options)\n            )\n              .done(function (result, textStatus, jqXHR) {\n                that._onDone(result, textStatus, jqXHR, options);\n              })\n              .fail(function (jqXHR, textStatus, errorThrown) {\n                that._onFail(jqXHR, textStatus, errorThrown, options);\n              })\n              .always(function (jqXHRorResult, textStatus, jqXHRorError) {\n                that._deinitProgressListener(options);\n                that._onAlways(\n                  jqXHRorResult,\n                  textStatus,\n                  jqXHRorError,\n                  options\n                );\n                that._sending -= 1;\n                that._active -= 1;\n                if (\n                  options.limitConcurrentUploads &&\n                  options.limitConcurrentUploads > that._sending\n                ) {\n                  // Start the next queued upload,\n                  // that has not been aborted:\n                  var nextSlot = that._slots.shift();\n                  while (nextSlot) {\n                    if (that._getDeferredState(nextSlot) === 'pending') {\n                      nextSlot.resolve();\n                      break;\n                    }\n                    nextSlot = that._slots.shift();\n                  }\n                }\n                if (that._active === 0) {\n                  // The stop callback is triggered when all uploads have\n                  // been completed, equivalent to the global ajaxStop event:\n                  that._trigger('stop');\n                }\n              });\n          return jqXHR;\n        };\n      this._beforeSend(e, options);\n      if (\n        this.options.sequentialUploads ||\n        (this.options.limitConcurrentUploads &&\n          this.options.limitConcurrentUploads <= this._sending)\n      ) {\n        if (this.options.limitConcurrentUploads > 1) {\n          slot = $.Deferred();\n          this._slots.push(slot);\n          pipe = slot[that._promisePipe](send);\n        } else {\n          this._sequence = this._sequence[that._promisePipe](send, send);\n          pipe = this._sequence;\n        }\n        // Return the piped Promise object, enhanced with an abort method,\n        // which is delegated to the jqXHR object of the current upload,\n        // and jqXHR callbacks mapped to the equivalent Promise methods:\n        pipe.abort = function () {\n          aborted = [undefined, 'abort', 'abort'];\n          if (!jqXHR) {\n            if (slot) {\n              slot.rejectWith(options.context, aborted);\n            }\n            return send();\n          }\n          return jqXHR.abort();\n        };\n        return this._enhancePromise(pipe);\n      }\n      return send();\n    },\n\n    _onAdd: function (e, data) {\n      var that = this,\n        result = true,\n        options = $.extend({}, this.options, data),\n        files = data.files,\n        filesLength = files.length,\n        limit = options.limitMultiFileUploads,\n        limitSize = options.limitMultiFileUploadSize,\n        overhead = options.limitMultiFileUploadSizeOverhead,\n        batchSize = 0,\n        paramName = this._getParamName(options),\n        paramNameSet,\n        paramNameSlice,\n        fileSet,\n        i,\n        j = 0;\n      if (!filesLength) {\n        return false;\n      }\n      if (limitSize && files[0].size === undefined) {\n        limitSize = undefined;\n      }\n      if (\n        !(options.singleFileUploads || limit || limitSize) ||\n        !this._isXHRUpload(options)\n      ) {\n        fileSet = [files];\n        paramNameSet = [paramName];\n      } else if (!(options.singleFileUploads || limitSize) && limit) {\n        fileSet = [];\n        paramNameSet = [];\n        for (i = 0; i < filesLength; i += limit) {\n          fileSet.push(files.slice(i, i + limit));\n          paramNameSlice = paramName.slice(i, i + limit);\n          if (!paramNameSlice.length) {\n            paramNameSlice = paramName;\n          }\n          paramNameSet.push(paramNameSlice);\n        }\n      } else if (!options.singleFileUploads && limitSize) {\n        fileSet = [];\n        paramNameSet = [];\n        for (i = 0; i < filesLength; i = i + 1) {\n          batchSize += files[i].size + overhead;\n          if (\n            i + 1 === filesLength ||\n            batchSize + files[i + 1].size + overhead > limitSize ||\n            (limit && i + 1 - j >= limit)\n          ) {\n            fileSet.push(files.slice(j, i + 1));\n            paramNameSlice = paramName.slice(j, i + 1);\n            if (!paramNameSlice.length) {\n              paramNameSlice = paramName;\n            }\n            paramNameSet.push(paramNameSlice);\n            j = i + 1;\n            batchSize = 0;\n          }\n        }\n      } else {\n        paramNameSet = paramName;\n      }\n      data.originalFiles = files;\n      $.each(fileSet || files, function (index, element) {\n        var newData = $.extend({}, data);\n        newData.files = fileSet ? element : [element];\n        newData.paramName = paramNameSet[index];\n        that._initResponseObject(newData);\n        that._initProgressObject(newData);\n        that._addConvenienceMethods(e, newData);\n        result = that._trigger(\n          'add',\n          $.Event('add', { delegatedEvent: e }),\n          newData\n        );\n        return result;\n      });\n      return result;\n    },\n\n    _replaceFileInput: function (data) {\n      var input = data.fileInput,\n        inputClone = input.clone(true),\n        restoreFocus = input.is(document.activeElement);\n      // Add a reference for the new cloned file input to the data argument:\n      data.fileInputClone = inputClone;\n      $('<form></form>').append(inputClone)[0].reset();\n      // Detaching allows to insert the fileInput on another form\n      // without loosing the file input value:\n      input.after(inputClone).detach();\n      // If the fileInput had focus before it was detached,\n      // restore focus to the inputClone.\n      if (restoreFocus) {\n        inputClone.trigger('focus');\n      }\n      // Avoid memory leaks with the detached file input:\n      $.cleanData(input.off('remove'));\n      // Replace the original file input element in the fileInput\n      // elements set with the clone, which has been copied including\n      // event handlers:\n      this.options.fileInput = this.options.fileInput.map(function (i, el) {\n        if (el === input[0]) {\n          return inputClone[0];\n        }\n        return el;\n      });\n      // If the widget has been initialized on the file input itself,\n      // override this.element with the file input clone:\n      if (input[0] === this.element[0]) {\n        this.element = inputClone;\n      }\n    },\n\n    _handleFileTreeEntry: function (entry, path) {\n      var that = this,\n        dfd = $.Deferred(),\n        entries = [],\n        dirReader,\n        errorHandler = function (e) {\n          if (e && !e.entry) {\n            e.entry = entry;\n          }\n          // Since $.when returns immediately if one\n          // Deferred is rejected, we use resolve instead.\n          // This allows valid files and invalid items\n          // to be returned together in one set:\n          dfd.resolve([e]);\n        },\n        successHandler = function (entries) {\n          that\n            ._handleFileTreeEntries(entries, path + entry.name + '/')\n            .done(function (files) {\n              dfd.resolve(files);\n            })\n            .fail(errorHandler);\n        },\n        readEntries = function () {\n          dirReader.readEntries(function (results) {\n            if (!results.length) {\n              successHandler(entries);\n            } else {\n              entries = entries.concat(results);\n              readEntries();\n            }\n          }, errorHandler);\n        };\n      // eslint-disable-next-line no-param-reassign\n      path = path || '';\n      if (entry.isFile) {\n        if (entry._file) {\n          // Workaround for Chrome bug #149735\n          entry._file.relativePath = path;\n          dfd.resolve(entry._file);\n        } else {\n          entry.file(function (file) {\n            file.relativePath = path;\n            dfd.resolve(file);\n          }, errorHandler);\n        }\n      } else if (entry.isDirectory) {\n        dirReader = entry.createReader();\n        readEntries();\n      } else {\n        // Return an empty list for file system items\n        // other than files or directories:\n        dfd.resolve([]);\n      }\n      return dfd.promise();\n    },\n\n    _handleFileTreeEntries: function (entries, path) {\n      var that = this;\n      return $.when\n        .apply(\n          $,\n          $.map(entries, function (entry) {\n            return that._handleFileTreeEntry(entry, path);\n          })\n        )\n        [this._promisePipe](function () {\n          return Array.prototype.concat.apply([], arguments);\n        });\n    },\n\n    _getDroppedFiles: function (dataTransfer) {\n      // eslint-disable-next-line no-param-reassign\n      dataTransfer = dataTransfer || {};\n      var items = dataTransfer.items;\n      if (\n        items &&\n        items.length &&\n        (items[0].webkitGetAsEntry || items[0].getAsEntry)\n      ) {\n        return this._handleFileTreeEntries(\n          $.map(items, function (item) {\n            var entry;\n            if (item.webkitGetAsEntry) {\n              entry = item.webkitGetAsEntry();\n              if (entry) {\n                // Workaround for Chrome bug #149735:\n                entry._file = item.getAsFile();\n              }\n              return entry;\n            }\n            return item.getAsEntry();\n          })\n        );\n      }\n      return $.Deferred().resolve($.makeArray(dataTransfer.files)).promise();\n    },\n\n    _getSingleFileInputFiles: function (fileInput) {\n      // eslint-disable-next-line no-param-reassign\n      fileInput = $(fileInput);\n      var entries =\n          fileInput.prop('webkitEntries') || fileInput.prop('entries'),\n        files,\n        value;\n      if (entries && entries.length) {\n        return this._handleFileTreeEntries(entries);\n      }\n      files = $.makeArray(fileInput.prop('files'));\n      if (!files.length) {\n        value = fileInput.prop('value');\n        if (!value) {\n          return $.Deferred().resolve([]).promise();\n        }\n        // If the files property is not available, the browser does not\n        // support the File API and we add a pseudo File object with\n        // the input value as name with path information removed:\n        files = [{ name: value.replace(/^.*\\\\/, '') }];\n      } else if (files[0].name === undefined && files[0].fileName) {\n        // File normalization for Safari 4 and Firefox 3:\n        $.each(files, function (index, file) {\n          file.name = file.fileName;\n          file.size = file.fileSize;\n        });\n      }\n      return $.Deferred().resolve(files).promise();\n    },\n\n    _getFileInputFiles: function (fileInput) {\n      if (!(fileInput instanceof $) || fileInput.length === 1) {\n        return this._getSingleFileInputFiles(fileInput);\n      }\n      return $.when\n        .apply($, $.map(fileInput, this._getSingleFileInputFiles))\n        [this._promisePipe](function () {\n          return Array.prototype.concat.apply([], arguments);\n        });\n    },\n\n    _onChange: function (e) {\n      var that = this,\n        data = {\n          fileInput: $(e.target),\n          form: $(e.target.form)\n        };\n      this._getFileInputFiles(data.fileInput).always(function (files) {\n        data.files = files;\n        if (that.options.replaceFileInput) {\n          that._replaceFileInput(data);\n        }\n        if (\n          that._trigger(\n            'change',\n            $.Event('change', { delegatedEvent: e }),\n            data\n          ) !== false\n        ) {\n          that._onAdd(e, data);\n        }\n      });\n    },\n\n    _onPaste: function (e) {\n      var items =\n          e.originalEvent &&\n          e.originalEvent.clipboardData &&\n          e.originalEvent.clipboardData.items,\n        data = { files: [] };\n      if (items && items.length) {\n        $.each(items, function (index, item) {\n          var file = item.getAsFile && item.getAsFile();\n          if (file) {\n            data.files.push(file);\n          }\n        });\n        if (\n          this._trigger(\n            'paste',\n            $.Event('paste', { delegatedEvent: e }),\n            data\n          ) !== false\n        ) {\n          this._onAdd(e, data);\n        }\n      }\n    },\n\n    _onDrop: function (e) {\n      e.dataTransfer = e.originalEvent && e.originalEvent.dataTransfer;\n      var that = this,\n        dataTransfer = e.dataTransfer,\n        data = {};\n      if (dataTransfer && dataTransfer.files && dataTransfer.files.length) {\n        e.preventDefault();\n        this._getDroppedFiles(dataTransfer).always(function (files) {\n          data.files = files;\n          if (\n            that._trigger(\n              'drop',\n              $.Event('drop', { delegatedEvent: e }),\n              data\n            ) !== false\n          ) {\n            that._onAdd(e, data);\n          }\n        });\n      }\n    },\n\n    _onDragOver: getDragHandler('dragover'),\n\n    _onDragEnter: getDragHandler('dragenter'),\n\n    _onDragLeave: getDragHandler('dragleave'),\n\n    _initEventHandlers: function () {\n      if (this._isXHRUpload(this.options)) {\n        this._on(this.options.dropZone, {\n          dragover: this._onDragOver,\n          drop: this._onDrop,\n          // event.preventDefault() on dragenter is required for IE10+:\n          dragenter: this._onDragEnter,\n          // dragleave is not required, but added for completeness:\n          dragleave: this._onDragLeave\n        });\n        this._on(this.options.pasteZone, {\n          paste: this._onPaste\n        });\n      }\n      if ($.support.fileInput) {\n        this._on(this.options.fileInput, {\n          change: this._onChange\n        });\n      }\n    },\n\n    _destroyEventHandlers: function () {\n      this._off(this.options.dropZone, 'dragenter dragleave dragover drop');\n      this._off(this.options.pasteZone, 'paste');\n      this._off(this.options.fileInput, 'change');\n    },\n\n    _destroy: function () {\n      this._destroyEventHandlers();\n    },\n\n    _setOption: function (key, value) {\n      var reinit = $.inArray(key, this._specialOptions) !== -1;\n      if (reinit) {\n        this._destroyEventHandlers();\n      }\n      this._super(key, value);\n      if (reinit) {\n        this._initSpecialOptions();\n        this._initEventHandlers();\n      }\n    },\n\n    _initSpecialOptions: function () {\n      var options = this.options;\n      if (options.fileInput === undefined) {\n        options.fileInput = this.element.is('input[type=\"file\"]')\n          ? this.element\n          : this.element.find('input[type=\"file\"]');\n      } else if (!(options.fileInput instanceof $)) {\n        options.fileInput = $(options.fileInput);\n      }\n      if (!(options.dropZone instanceof $)) {\n        options.dropZone = $(options.dropZone);\n      }\n      if (!(options.pasteZone instanceof $)) {\n        options.pasteZone = $(options.pasteZone);\n      }\n    },\n\n    _getRegExp: function (str) {\n      var parts = str.split('/'),\n        modifiers = parts.pop();\n      parts.shift();\n      return new RegExp(parts.join('/'), modifiers);\n    },\n\n    _isRegExpOption: function (key, value) {\n      return (\n        key !== 'url' &&\n        $.type(value) === 'string' &&\n        /^\\/.*\\/[igm]{0,3}$/.test(value)\n      );\n    },\n\n    _initDataAttributes: function () {\n      var that = this,\n        options = this.options,\n        data = this.element.data();\n      // Initialize options set via HTML5 data-attributes:\n      $.each(this.element[0].attributes, function (index, attr) {\n        var key = attr.name.toLowerCase(),\n          value;\n        if (/^data-/.test(key)) {\n          // Convert hyphen-ated key to camelCase:\n          key = key.slice(5).replace(/-[a-z]/g, function (str) {\n            return str.charAt(1).toUpperCase();\n          });\n          value = data[key];\n          if (that._isRegExpOption(key, value)) {\n            value = that._getRegExp(value);\n          }\n          options[key] = value;\n        }\n      });\n    },\n\n    _create: function () {\n      this._initDataAttributes();\n      this._initSpecialOptions();\n      this._slots = [];\n      this._sequence = this._getXHRPromise(true);\n      this._sending = this._active = 0;\n      this._initProgressObject(this);\n      this._initEventHandlers();\n    },\n\n    // This method is exposed to the widget API and allows to query\n    // the number of active uploads:\n    active: function () {\n      return this._active;\n    },\n\n    // This method is exposed to the widget API and allows to query\n    // the widget upload progress.\n    // It returns an object with loaded, total and bitrate properties\n    // for the running uploads:\n    progress: function () {\n      return this._progress;\n    },\n\n    // This method is exposed to the widget API and allows adding files\n    // using the fileupload API. The data parameter accepts an object which\n    // must have a files property and can contain additional options:\n    // .fileupload('add', {files: filesList});\n    add: function (data) {\n      var that = this;\n      if (!data || this.options.disabled) {\n        return;\n      }\n      if (data.fileInput && !data.files) {\n        this._getFileInputFiles(data.fileInput).always(function (files) {\n          data.files = files;\n          that._onAdd(null, data);\n        });\n      } else {\n        data.files = $.makeArray(data.files);\n        this._onAdd(null, data);\n      }\n    },\n\n    // This method is exposed to the widget API and allows sending files\n    // using the fileupload API. The data parameter accepts an object which\n    // must have a files or fileInput property and can contain additional options:\n    // .fileupload('send', {files: filesList});\n    // The method returns a Promise object for the file upload call.\n    send: function (data) {\n      if (data && !this.options.disabled) {\n        if (data.fileInput && !data.files) {\n          var that = this,\n            dfd = $.Deferred(),\n            promise = dfd.promise(),\n            jqXHR,\n            aborted;\n          promise.abort = function () {\n            aborted = true;\n            if (jqXHR) {\n              return jqXHR.abort();\n            }\n            dfd.reject(null, 'abort', 'abort');\n            return promise;\n          };\n          this._getFileInputFiles(data.fileInput).always(function (files) {\n            if (aborted) {\n              return;\n            }\n            if (!files.length) {\n              dfd.reject();\n              return;\n            }\n            data.files = files;\n            jqXHR = that._onSend(null, data);\n            jqXHR.then(\n              function (result, textStatus, jqXHR) {\n                dfd.resolve(result, textStatus, jqXHR);\n              },\n              function (jqXHR, textStatus, errorThrown) {\n                dfd.reject(jqXHR, textStatus, errorThrown);\n              }\n            );\n          });\n          return this._enhancePromise(promise);\n        }\n        data.files = $.makeArray(data.files);\n        if (data.files.length) {\n          return this._onSend(null, data);\n        }\n      }\n      return this._getXHRPromise(false, data && data.context);\n    }\n  });\n});\n"]}