NDOJ/resources/fine-uploader/fine-uploader.core.min.js.map

{"version":3,"sources":["?","../client/js/util.js","../client/js/export.js","../client/js/error/error.js","../client/js/version.js","../client/js/features.js","../client/js/promise.js","../client/js/blob-proxy.js","../client/js/button.js","../client/js/upload-data.js","../client/js/uploader.basic.api.js","../client/js/uploader.basic.js","../client/js/ajax.requester.js","../client/js/upload-handler/upload.handler.js","../client/js/upload-handler/upload.handler.controller.js","../client/js/window.receive.message.js","../client/js/upload-handler/form.upload.handler.js","../client/js/upload-handler/xhr.upload.handler.js","../client/js/deletefile.ajax.requester.js","../client/js/image-support/megapix-image.js","../client/js/image-support/image.js","../client/js/image-support/exif.js","../client/js/identify.js","../client/js/image-support/validation.image.js","../client/js/session.js","../client/js/session.ajax.requester.js","../client/js/image-support/scaler.js","../client/js/third-party/ExifRestorer.js","../client/js/total-progress.js","../client/js/paste.js","../client/js/form-support.js","../client/js/traditional/traditional.form.upload.handler.js","../client/js/traditional/traditional.xhr.upload.handler.js","../client/js/traditional/all-chunks-done.ajax.requester.js"],"names":["global","qq","element","hide","style","display","this","attach","type","fn","addEventListener","attachEvent","detach","removeEventListener","detachEvent","contains","descendant","compareDocumentPosition","insertBefore","elementB","parentNode","remove","removeChild","css","styles","Error","opacity","filter","Math","round","extend","hasClass","name","considerParent","re","RegExp","test","className","addClass","removeClass","replace","getByClass","first","candidates","result","querySelector","querySelectorAll","getElementsByTagName","each","idx","val","push","getFirstByClass","children","child","firstChild","nodeType","nextSibling","setText","text","innerText","textContent","clearText","hasAttribute","attrName","attrVal","exec","getAttribute","undefined","canvasToBlob","canvas","mime","quality","dataUriToBlob","toDataURL","dataUri","arrayBuffer","byteString","intArray","mimeString","createBlob","data","BlobBuilder","window","WebKitBlobBuilder","MozBlobBuilder","MSBlobBuilder","blobBuilder","append","getBlob","Blob","split","indexOf","atob","decodeURI","ArrayBuffer","length","Uint8Array","character","charCodeAt","log","message","level","console","isObject","variable","Object","prototype","toString","call","isFunction","isArray","value","buffer","constructor","isItemList","maybeItemList","isNodeList","maybeNodeList","item","namedItem","isString","maybeString","trimStr","string","String","trim","format","str","args","Array","slice","arguments","newStr","nextIdxToReplace","substring","isFile","maybeFile","File","isFileList","maybeFileList","FileList","isFileOrInput","maybeFileOrInput","isInput","maybeInput","notFile","evaluateType","normalizedType","toLowerCase","HTMLInputElement","tagName","isBlob","maybeBlob","isXhrUploadSupported","input","document","createElement","multiple","FormData","createXhrInstance","upload","XMLHttpRequest","ActiveXObject","error","isFolderDropSupported","dataTransfer","items","webkitGetAsEntry","isFileChunkingSupported","androidStock","webkitSlice","mozSlice","sliceBlob","fileOrBlob","start","end","arrayBufferToHex","bytesAsHex","bytes","byt","byteAsHexStr","readBlobToHex","blob","startOffset","initialBlob","fileReader","FileReader","promise","Promise","onload","success","onerror","failure","readAsArrayBuffer","second","extendNested","prop","override","target","sourceFn","super_","source","srcPropName","srcPropVal","arr","elt","from","len","hasOwnProperty","getUniqueId","c","r","random","ie","navigator","userAgent","ie7","ie8","ie10","ie11","edge","safari","vendor","chrome","opera","firefox","windows","platform","android","ios6","ios","ios7","ios8","ios800","iosChrome","iosSafari","iosSafariWebView","preventDefault","e","returnValue","toElement","div","html","innerHTML","iterableItem","callback","keyOrIndex","retVal","Storage","key","getItem","charAt","bind","oldFunc","context","newArgs","concat","apply","obj2url","obj","temp","prefixDone","uristrings","prefix","add","nextObj","i","nextTemp","encodeURIComponent","join","obj2FormData","formData","arrayKeyName","obj2Inputs","form","setAttribute","appendChild","parseJson","json","JSON","parse","eval","getExtension","filename","extIdx","lastIndexOf","substr","getFilename","blobOrFileInput","fileName","DisposeSupport","disposers","dispose","disposer","shift","addDisposer","disposeFunction","define","amd","module","exports","version","supportedFeatures","testSupportsFileInputElement","tempInput","supported","disabled","ex","isChrome14OrHigher","match","isCrossOriginXhrSupported","withCredentials","isXdrSupported","XDomainRequest","isCrossOriginAjaxSupported","isFolderSelectionSupported","webkitdirectory","isLocalStorageSupported","localStorage","setItem","isDragAndDropSupported","span","supportsUploading","supportsUploadingBlobs","supportsFileDrop","supportsAjaxFileUploading","supportsFolderDrop","supportsChunking","supportsResume","supportsUploadViaPaste","supportsUploadCors","supportsDeleteFileXdr","supportsDeleteFileCorsXhr","supportsDeleteFileCors","supportsFolderSelection","supportsImagePreviews","supportsUploadProgress","postMessage","ajaxUploading","blobUploading","canDetermineSize","chunking","deleteFileCors","deleteFileCorsXdr","deleteFileCorsXhr","dialogElement","HTMLDialogElement","fileDrop","folderDrop","folderSelection","imagePreviews","imageValidation","itemSizeValidation","pause","progressBar","resume","scaling","tiffPreviews","unlimitedScaledImageSize","uploading","uploadCors","uploadCustomHeaders","uploadNonMultipart","uploadViaPaste","isGenericPromise","maybePromise","then","successArgs","failureArgs","successCallbacks","failureCallbacks","doneCallbacks","state","onSuccess","onFailure","done","BlobProxy","referenceBlob","onCreate","create","UploadButton","o","createInput","BUTTON_ID_ATTR_NAME","buttonId","options","title","self","setMultiple","folders","acceptFiles","position","right","top","fontFamily","fontSize","margin","padding","cursor","height","disposeSupport","onChange","hoverClass","focusClass","ios8BrowserCrashWorkaround","overflow","direction","getInput","getButtonId","isMultiple","optInput","removeAttribute","setAcceptFiles","reset","UploadData","uploaderProxy","getDataByIds","idOrIds","entries","id","getDataByUuids","uuids","uuid","byUuid","getDataByStatus","status","statusResults","statuses","index","statusEnum","statusResultIndexes","byStatus","dataIndex","byProxyGroupId","byBatchId","addFile","spec","SUBMITTING","originalName","size","file","batchId","proxyGroupId","onBeforeStatusChange","onStatusChange","retrieve","optionalFilter","removeFileRef","record","setStatus","newStatus","oldStatus","byStatusOldStatusIndex","splice","uuidChanged","newUuid","oldUuid","updateName","newName","updateSize","newSize","setParentId","targetId","parentId","getIdsInProxyGroup","getIdsInBatch","SUBMITTED","REJECTED","QUEUED","CANCELED","PAUSED","UPLOADING","UPLOAD_FINALIZING","UPLOAD_RETRYING","UPLOAD_SUCCESSFUL","UPLOAD_FAILED","DELETE_FAILED","DELETING","DELETED","basePublicApi","addBlobs","blobDataOrArray","params","endpoint","addFiles","addInitialFiles","cannedFileList","cannedFile","_addCannedFile","_maybeHandleIos8SafariWorkaround","_storedIds","_currentBatchId","processBlob","_handleNewFile","_options","blobs","defaultName","verifiedFiles","processBlobData","blobData","processCanvas","processCanvasData","canvasData","normalizedQuality","processFileOrInput","fileOrInput","files","normalizeData","fileContainer","_prepareItemsForUpload","cancel","uploadData","_uploadData","getName","_handler","cancelAll","storedIdsCopy","storedFileId","clearStoredFiles","continueUpload","enabled","_uploadFile","deleteFile","_onSubmitDelete","doesExist","fileOrBlobId","isValid","drawThumbnail","fileId","imgOrCanvas","maxSize","fromServer","customResizeFunction","fileOrUrl","promiseToReturn","_imageGenerator","_thumbnailUrls","scale","getFile","container","generate","modifiedContainer","reason","getButton","_getButton","_buttonIdsForFileIds","getEndpoint","_endpointStore","get","uploadDataRecord","getInProgress","getParentId","uploadDataEntry","getUploads","getResumableFilesData","getSize","getNetUploads","_netUploaded","getRemainingAllowedItems","allowedItems","_currentItemLimit","_netUploadedOrQueued","getUuid","isResumable","hasResumeRecord","debug","pauseUpload","expunge","_autoRetries","_retryTimeouts","_preventRetries","_buttons","button","_paramsStore","_pasteHandler","session","refreshOnReset","_refreshSessionData","_succeededSinceLastAllComplete","_failedSinceLastAllComplete","_totalProgress","_customResumeDataStore","retry","_manualRetry","scaleImage","specs","Scaler","setCustomHeaders","headers","_customHeadersStore","set","setCustomResumeData","setDeleteFileCustomHeaders","_deleteFileCustomHeadersStore","setDeleteFileEndpoint","_deleteFileEndpointStore","setDeleteFileParams","_deleteFileParamsStore","setEndpoint","setForm","elementOrId","_updateFormSupportAndParams","setItemLimit","newItemLimit","setName","setParams","setUuid","_onDeleteComplete","errorMessage","uploadStoredFiles","_itemError","_uploadStoredFiles","basePrivateApi","sessionData","deleteFileEndpoint","deleteFileParams","thumbnailUrl","_annotateWithButtonId","associatedInput","qqButtonId","_getButtonId","_batchError","callbacks","onError","_createDeleteHandler","DeleteFileAjaxRequester","method","toUpperCase","maxConnections","uuidParamName","request","uuidName","customHeaders","paramsStore","endpointStore","cors","onDelete","_onDelete","onDeleteComplete","xhrOrXdr","isError","_createPasteHandler","PasteSupport","targetElement","paste","pasteReceived","_handleCheckedCallback","onPasteReceived","_handlePasteSuccess","identifier","_createStore","initialValue","_readOnlyValues_","store","catchall","perIdReadOnlyValues","readOnlyValues","copy","orig","getReadOnlyValues","includeReadOnlyValues","existing","values","addReadOnly","_createUploadDataTracker","_onUploadStatusChange","_maybeAllComplete","setTimeout","_createUploadButton","allowMultiple","workarounds","iosEmptyVideos","_isAllowedExtension","allowedExtensions","accept","validation","classes","buttonFocus","buttonHover","ios8BrowserCrash","inputName","_onInputChange","fileInputTitle","_disposeSupport","_createUploadHandler","additionalOptions","namespace","lastOnProgress","preventRetryParam","preventRetryResponseProperty","onProgress","loaded","total","_onProgress","onComplete","xhr","_onComplete","onCancel","cancelFinalizationEffort","_onCancel","onUploadPrep","_onUploadPrep","onUpload","_onUpload","onUploadResult","onUploadChunk","chunkData","_onUploadChunk","onUploadChunkResult","partIndex","onUploadChunkSuccess","_onUploadChunkSuccess","onResume","customResumeData","onAutoRetry","responseJSON","_onAutoRetry","onUuidChanged","setSize","_setSize","getDataByUuid","isQueued","isInProgress","getCustomResumeData","_getCustomResumeData","UploadHandlerController","_fileOrBlobRejected","_formatSize","sizeSymbols","max","toFixed","_generateExtraButtonSpecs","_extraButtonSpecs","extraButtons","extraButtonOptionEntry","extraButtonSpec","_initExtraButton","extraButtonsSpec","_defaultButtonId","buttonOrFileInputOrFile","inputs","fileInput","fileBlobOrInput","_getNotFinished","_getValidationBase","_getValidationDescriptor","fileWrapper","_getValidationDescriptors","fileWrappers","fileDescriptors","_handleCameraAccess","camera","optionRoot","details","callbackRetVal","successParam","newFileWrapperList","actualFile","handler","_customNewFileHandler","_handleNewFileGeneric","addFileToHandler","_trackButton","fileList","extSuppliedName","extension","_handleDeleteSuccess","_handleDeleteFailed","_initFormSupportAndParams","_formSupport","FormSupport","attachedToForm","getFormInputsAsObject","autoUpload","newAutoUpload","newEndpoint","_isDeletePossible","expected","allowXdr","allowed","valid","allowedExt","extRegex","code","maybeNameOrNames","replacement","extensionsForMessage","placeholderMatch","messages","names","validationBase","allowedExtension","formatFileName","sizeLimit","minSizeLimit","placeholder","_onBeforeManualRetry","notFinished","_onAllComplete","ios8SafariUploads","alert","unsupportedBrowserIos8Safari","_maybeParseAndSendUploadError","response","errorReason","defaultResponseError","_maybeProcessNextItemAfterOnValidateCallback","validItem","stopOnFirstInvalidFile","validationDescriptor","onValidate","_onValidateCallbackSuccess","_onValidateCallbackFailure","successful","failed","onAllComplete","_shouldAutoRetry","retryWaitPeriod","autoAttemptDelay","_onBeforeAutoRetry","itemLimit","onManualRetry","clearTimeout","storedItemIndex","fileIndex","onIndividualProgress","_onSubmit","_onSubmitCallbackSuccess","_onSubmitted","onSubmitted","_storeForLater","onSuccessCallback","additionalMandatedParams","adjustedOnSuccessCallback","onSubmitDelete","_deleteHandler","sendDelete","_onTotalProgress","onTotalProgress","enableAuto","_onValidateBatchCallbackFailure","_onValidateBatchCallbackSuccess","validationDescriptors","proposedNetFilesUploadedOrQueued","tooManyItemsError","nextIndex","_validateFileOrBlobData","_upload","onValidateBatch","_preventLeaveInProgress","event","onLeave","Session","_session","addFileRecord","refresh","_sessionRequestComplete","onSessionRequestComplete","onNewSize","maxAutoAttempts","formElementOrId","onSubmit","idToUpload","stillSubmitting","validityChecker","allowEmpty","ImageValidation","validate","image","errorCode","_wrapCallbacks","safeCallback","errorMsg","exception","callbackName","callbackFunc","FineUploaderBasic","disableCancelForFormUploads","warnBeforeUnload","filenameParam","forceMultipart","omitDefaultParams","paramsInBody","requireSuccessJson","totalFileSizeName","maxHeight","maxWidth","minHeight","minWidth","maybeXhr","maybeXhrOrXdr","attemptNumber","fileOrBlobData","typeError","sizeError","minSizeError","emptyError","noFilesError","maxHeightImageError","maxWidthImageError","minHeightImageError","minWidthImageError","retryFailTooManyItems","concurrent","mandatory","paramNames","partByteOffset","chunkSize","totalFileSize","totalParts","partSize","jsonPayload","resetOnStatus","recordsExpireIn","resuming","customKeys","fileOrBlobName","sendCredentials","interceptSubmit","customResizer","sendOriginal","orient","defaultType","defaultQuality","failureText","includeExif","sizes","ImageGenerator","_scaler","handleNewFile","TotalProgress","entry","AjaxRequester","isSimpleMethod","containsNonSimpleHeaders","containsNonSimple","header","isXdr","getCorsAjaxTransport","ontimeout","onprogress","getXhrOrXdr","suppliedXhr","requestData","dequeue","nextId","queue","sendRequest","xdrError","isResponseSuccessful","getParams","onDemandParams","additionalParams","mandatedParams","optXhr","url","payload","onSend","createUrl","additionalQueryParams","getXdrLoadHandler","getXdrErrorHandler","onreadystatechange","getXhrReadyStateChangeHandler","registerForUploadProgress","open","setHeaders","send","shouldParamsBeInQueryString","contentType","stringify","addToPath","readyState","lengthComputable","onDemandHeaders","additionalHeaders","allHeaders","acceptHeader","setRequestHeader","allowXRequestedWithAndCacheControl","responseCode","successfulResponseCodes","prepareToSend","validMethods","DELETE","PATCH","POST","PUT","GET","initTransport","path","cacheBuster","withPath","appendToPath","withParams","withQueryParams","_additionalQueryParams_","withHeaders","withPayload","thePayload","withCacheBuster","qqtimestamp","Date","getTime","canceled","UploadHandler","proxy","fileState","fileItem","getThirdPartyFileId","_getFileState","_setThirdPartyFileId","thirdPartyFileId","_wasCanceled","preventRetryResponse","controller","chunkingPossible","concurrentChunkingPossible","chunked","chunkIdx","_getChunkData","attemptingResume","chunkProgress","_getChunkDataForCallback","finalize","finalizeChunks","normaizedResponse","normalizeResponse","_maybeDeletePersistedChunkData","cleanup","normalizedResponse","handleFailure","clearCachedChunk","inProgressIdx","responseToReport","inProgressChunksArray","inProgress","remaining","unshift","ignoreFailure","keys","_getXhrs","ckid","ckXhr","abort","_cancelled","moveInProgressToRemaining","connectionManager","free","hasMoreParts","nextPart","nextIdx","_getTotalChunks","reevaluateChunking","sendNext","inProgressChunks","available","requestOverrides","uploadChunkData","overrides","uploadChunk","inProgressChunkIdx","_maybePersistChunkedState","clearXhr","_open","_openChunks","_waiting","openChunkEntriesCount","openChunksCount","openChunkIndexes","dontAllowNext","allowNext","waitingIndex","connectionsIndex","getProxyOrBlob","getWaitingOrConnected","waitingOrConnected","chunks","parseInt","isUsingConnection","pop","openChunksEntry","simple","uploadFile","maybeNewUuid","_clearXhrs","getProxy","initHandler","traditional","onFinalizing","_removeExpiredChunkingRecords","isDeferredEligibleForUpload","maybeDefer","generatedBlob","updateBlob","maybeSendDeferredFiles","errorResponse","idsInGroup","uploadedThisId","idInGroup","now","originalResponse","_shouldChunkThisFile","blobToUpload","cancelRetVal","isProxied","_getLocalStorageId","isAttemptingResume","WindowReceiveMessage","callbackWrapperDetachers","receiveMessage","onMessageCallbackWrapper","stopReceivingMessages","detacher","FormUploadHandler","expungeFile","detachLoadEvents","isCors","postMessageCallbackTimers","corsMessageReceiver","iframe","getElementById","_getIframeName","getFileIdForIframeName","iframeName","initIframeForUpload","body","registerPostMessageCallback","onloadCallbacks","onloadCallback","_parseJsonResponse","_detachLoadEvent","formHandlerInstanceId","_attachLoadEvent","responseDescriptor","contentDocument","_createIframe","_initFormForUpload","targetName","innerHtmlOrMessage","XhrUploadHandler","xhrId","ajaxRequester","_getAjaxRequester","getChunkSize","chunkFiles","resumeEnabled","blobOrProxy","_initTempState","_maybePrepareForResume","cachedChunks","tempState","xhrs","ajaxRequesters","responseParser","lastChunkIdx","_getXhr","resumableFilesData","_iterateResumeRecords","notResumable","optInProgress","optRemaining","chunkingState","reverse","paused","totalChunks","parts","newBlob","chunkId","_createXhr","optChunkIdx","_registerXhr","chunkIndex","fileSize","startBytes","endBytes","part","count","startByte","endByte","localStorageId","forEach","_getMimeType","_getPersistableData","ceil","_markNotResumable","removeItem","persistedData","lastUpdated","_registerProgressHandler","progressCalculator","totalSuccessfullyLoadedForFile","loadedForRequest","totalForRequest","estActualChunkLoaded","totalLoadedForFile","chunkLoaded","optAjaxRequester","xhrsId","expirationDays","expirationDate","setDate","getDate","getMandatedParams","_method","requester","detectSubsampling","img","ctx","iw","naturalWidth","ih","naturalHeight","width","getContext","drawImage","getImageData","detectVerticalSquash","alpha","ratio","sy","ey","py","renderImageToDataURL","doSquash","renderImageToCanvas","maybeCalculateDownsampledDimensions","origHeight","origWidth","newHeight","sqrt","newWidth","modifiedDimensions","save","resize","renderImageToCanvasWithCustomResizer","imageHeight","imageWidth","orientation","targetHeight","targetWidth","transformCoordinate","tmpCtx","sx","dx","d","tmpCanvas","vertSquashRatio","dw","dh","dy","clearRect","restore","qqImageRendered","resizeInfo","sourceCanvas","sourceCanvasContext","targetCanvas","translate","rotate","PI","MegaPixImage","srcImage","errorCallback","Image","URL","createObjectURL","webkitURL","src","listeners","imageLoadListeners","render","opt","imgWidth","imgHeight","optionsKey","optionsValue","oldTargetSrc","onrender","isImg","el","isCanvas","isImgCorsSupported","crossOrigin","isCanvasSupported","determineMimeOfFileName","nameWithPath","pathSegments","isCrossOrigin","targetProtocol","targetHostname","targetPort","targetAnchor","href","protocol","port","hostname","location","registerImgLoadListeners","registerCanvasDrawImageListener","registerThumbnailRenderedListener","registered","draw","drawPreview","Identify","megapixErrorHandler","isPreviewable","dummyExif","exif","Exif","mpImg","Orientation","failureMsg","drawOnCanvasOrImgFromUrl","canvasOrImg","tempImg","tempImgRender","drawOnImgFromUrlWithCssScaling","drawFromUrl","fileBlobOrUrl","_testing","parseLittleEndian","hex","pow","seekToApp1","offset","theOffset","thePromise","segmentLength","getApp1Offset","isLittleEndian","app1Start","getDirEntryCount","littleEndian","getIfd","dirEntries","getDirEntries","ifdHex","getTagValues","tagsToFind","TAG_IDS","vals","tagValHex","tagValLength","idHex","tagsToFindIdx","TAG_INFO","274","parser","onParseFailure","app1Offset","dirEntryCount","tagValues","isIdentifiable","magicBytes","questionableBytes","identifiable","magicBytesEntries","magicBytesArrayEntry","previewable","isPreviewableSync","PREVIEWABLE_MIME_TYPES","fileMime","isRecognizedImage","image/jpeg","image/gif","image/png","image/bmp","image/tiff","hasNonZeroLimits","limits","atLeastOne","limit","getWidthHeight","sizeDetermination","getFailingLimit","dimensions","failingLimit","limitName","limitValue","limitMatcher","dimensionPropName","actualValue","validationEffort","isJsonResponseValid","handleFileItems","fileItems","someItemsIgnored","err","refreshEffort","refreshCompleteCallback","requesterOptions","SessionAjaxRequester","queryServer","responseText","includeOriginal","failedToScaleText","_getSortedSizes","getFileRecords","originalFileUuid","originalFileName","originalBlobOrBlobData","records","originalBlob","sizeRecord","outputType","_determineOutputType","requestedType","refType","_getName","_generateScaledImage","failedText","api","scaledIds","originalId","blobSize","scaledId","qqparentuuid","qqparentsize","param","scalingEffort","scalingOptions","scaler","referenceType","scaledVersionProperties","startOfExt","versionType","scaledName","scaledExt","nameAppendage","sort","a","b","sourceFile","imageGenerator","scaledImageDataUri","signalSuccess","_insertExifHeader","scaledImageDataUriWithExif","originalImage","reader","insertionEffort","originalImageDataUri","ExifRestorer","readAsDataURL","_dataUriToBlob","_createBlob","KEY_STR","encode64","chr1","chr2","enc1","enc2","enc3","output","chr3","enc4","isNaN","origFileBase64","resizedFileBase64","rawImage","decode64","segments","slice2Segments","exifManipulation","exifArray","getExifArray","newImageArray","insertExif","seg","x","imageData","buf","separatePoint","mae","ato","array","rawImageArray","head","endPoint","perFileProgress","totalLoaded","totalSize","lastLoadedSent","lastTotalSent","callbackProxy","noRetryableFiles","retryable","none","failedId","updateTotalProgress","onNew","newLoaded","newTotal","oldLoaded","oldTotal","isImage","registerPasteHandler","detachPasteHandler","clipboardData","getAsFile","unregisterPasteHandler","startUpload","determineNewEndpoint","formEl","validateForm","nativeSubmit","checkValidity","maybeUploadOnSubmit","submit","determineFormEl","_form2Obj","notIrrelevantType","irrelevantTypes","radioOrCheckbox","ignoreValue","checked","selectValue","select","selected","elements","getIframeContentJson","doc","innerHtml","contentWindow","nodeValue","createForm","responseFromMessage","multipart","addChunkingSpecificParams","allChunksDoneRequester","AllChunksDoneAjaxRequester","createReadyStateChangedHandler","onUploadOrChunkComplete","getChunksCompleteParams","isErrorUploadResponse","parseResponse","sendChunksCompleteRequest","complete","setParamsAndGetEntityToSend","entityToSendParams","xhrOverrides","customParams","defaultParams","xhrOverrideParams","setUploadHeaders","headersOptions","headerOverrides","headerName","headerValue","extraHeaders","uploadChunkParams","toSend","promises","endpointHandler"],"mappings":"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","file":"fine-uploader.core.min.js","sourcesContent":[null,"/*globals window, navigator, document, FormData, File, HTMLInputElement, XMLHttpRequest, Blob, Storage, ActiveXObject */\n/* jshint -W079 */\nvar qq = function(element) {\n    \"use strict\";\n\n    return {\n        hide: function() {\n            element.style.display = \"none\";\n            return this;\n        },\n\n        /** Returns the function which detaches attached event */\n        attach: function(type, fn) {\n            if (element.addEventListener) {\n                element.addEventListener(type, fn, false);\n            } else if (element.attachEvent) {\n                element.attachEvent(\"on\" + type, fn);\n            }\n            return function() {\n                qq(element).detach(type, fn);\n            };\n        },\n\n        detach: function(type, fn) {\n            if (element.removeEventListener) {\n                element.removeEventListener(type, fn, false);\n            } else if (element.attachEvent) {\n                element.detachEvent(\"on\" + type, fn);\n            }\n            return this;\n        },\n\n        contains: function(descendant) {\n            // The [W3C spec](http://www.w3.org/TR/domcore/#dom-node-contains)\n            // says a `null` (or ostensibly `undefined`) parameter\n            // passed into `Node.contains` should result in a false return value.\n            // IE7 throws an exception if the parameter is `undefined` though.\n            if (!descendant) {\n                return false;\n            }\n\n            // compareposition returns false in this case\n            if (element === descendant) {\n                return true;\n            }\n\n            if (element.contains) {\n                return element.contains(descendant);\n            } else {\n                /*jslint bitwise: true*/\n                return !!(descendant.compareDocumentPosition(element) & 8);\n            }\n        },\n\n        /**\n         * Insert this element before elementB.\n         */\n        insertBefore: function(elementB) {\n            elementB.parentNode.insertBefore(element, elementB);\n            return this;\n        },\n\n        remove: function() {\n            element.parentNode.removeChild(element);\n            return this;\n        },\n\n        /**\n         * Sets styles for an element.\n         * Fixes opacity in IE6-8.\n         */\n        css: function(styles) {\n            /*jshint eqnull: true*/\n            if (element.style == null) {\n                throw new qq.Error(\"Can't apply style to node as it is not on the HTMLElement prototype chain!\");\n            }\n\n            /*jshint -W116*/\n            if (styles.opacity != null) {\n                if (typeof element.style.opacity !== \"string\" && typeof (element.filters) !== \"undefined\") {\n                    styles.filter = \"alpha(opacity=\" + Math.round(100 * styles.opacity) + \")\";\n                }\n            }\n            qq.extend(element.style, styles);\n\n            return this;\n        },\n\n        hasClass: function(name, considerParent) {\n            var re = new RegExp(\"(^| )\" + name + \"( |$)\");\n            return re.test(element.className) || !!(considerParent && re.test(element.parentNode.className));\n        },\n\n        addClass: function(name) {\n            if (!qq(element).hasClass(name)) {\n                element.className += \" \" + name;\n            }\n            return this;\n        },\n\n        removeClass: function(name) {\n            var re = new RegExp(\"(^| )\" + name + \"( |$)\");\n            element.className = element.className.replace(re, \" \").replace(/^\\s+|\\s+$/g, \"\");\n            return this;\n        },\n\n        getByClass: function(className, first) {\n            var candidates,\n                result = [];\n\n            if (first && element.querySelector) {\n                return element.querySelector(\".\" + className);\n            }\n            else if (element.querySelectorAll) {\n                return element.querySelectorAll(\".\" + className);\n            }\n\n            candidates = element.getElementsByTagName(\"*\");\n\n            qq.each(candidates, function(idx, val) {\n                if (qq(val).hasClass(className)) {\n                    result.push(val);\n                }\n            });\n            return first ? result[0] : result;\n        },\n\n        getFirstByClass: function(className) {\n            return qq(element).getByClass(className, true);\n        },\n\n        children: function() {\n            var children = [],\n                child = element.firstChild;\n\n            while (child) {\n                if (child.nodeType === 1) {\n                    children.push(child);\n                }\n                child = child.nextSibling;\n            }\n\n            return children;\n        },\n\n        setText: function(text) {\n            element.innerText = text;\n            element.textContent = text;\n            return this;\n        },\n\n        clearText: function() {\n            return qq(element).setText(\"\");\n        },\n\n        // Returns true if the attribute exists on the element\n        // AND the value of the attribute is NOT \"false\" (case-insensitive)\n        hasAttribute: function(attrName) {\n            var attrVal;\n\n            if (element.hasAttribute) {\n\n                if (!element.hasAttribute(attrName)) {\n                    return false;\n                }\n\n                /*jshint -W116*/\n                return (/^false$/i).exec(element.getAttribute(attrName)) == null;\n            }\n            else {\n                attrVal = element[attrName];\n\n                if (attrVal === undefined) {\n                    return false;\n                }\n\n                /*jshint -W116*/\n                return (/^false$/i).exec(attrVal) == null;\n            }\n        }\n    };\n};\n\n(function() {\n    \"use strict\";\n\n    qq.canvasToBlob = function(canvas, mime, quality) {\n        return qq.dataUriToBlob(canvas.toDataURL(mime, quality));\n    };\n\n    qq.dataUriToBlob = function(dataUri) {\n        var arrayBuffer, byteString,\n            createBlob = function(data, mime) {\n                var BlobBuilder = window.BlobBuilder ||\n                        window.WebKitBlobBuilder ||\n                        window.MozBlobBuilder ||\n                        window.MSBlobBuilder,\n                    blobBuilder = BlobBuilder && new BlobBuilder();\n\n                if (blobBuilder) {\n                    blobBuilder.append(data);\n                    return blobBuilder.getBlob(mime);\n                }\n                else {\n                    return new Blob([data], {type: mime});\n                }\n            },\n            intArray, mimeString;\n\n        // convert base64 to raw binary data held in a string\n        if (dataUri.split(\",\")[0].indexOf(\"base64\") >= 0) {\n            byteString = atob(dataUri.split(\",\")[1]);\n        }\n        else {\n            byteString = decodeURI(dataUri.split(\",\")[1]);\n        }\n\n        // extract the MIME\n        mimeString = dataUri.split(\",\")[0]\n            .split(\":\")[1]\n            .split(\";\")[0];\n\n        // write the bytes of the binary string to an ArrayBuffer\n        arrayBuffer = new ArrayBuffer(byteString.length);\n        intArray = new Uint8Array(arrayBuffer);\n        qq.each(byteString, function(idx, character) {\n            intArray[idx] = character.charCodeAt(0);\n        });\n\n        return createBlob(arrayBuffer, mimeString);\n    };\n\n    qq.log = function(message, level) {\n        if (window.console) {\n            if (!level || level === \"info\") {\n                window.console.log(message);\n            }\n            else\n            {\n                if (window.console[level]) {\n                    window.console[level](message);\n                }\n                else {\n                    window.console.log(\"<\" + level + \"> \" + message);\n                }\n            }\n        }\n    };\n\n    qq.isObject = function(variable) {\n        return variable && !variable.nodeType && Object.prototype.toString.call(variable) === \"[object Object]\";\n    };\n\n    qq.isFunction = function(variable) {\n        return typeof (variable) === \"function\";\n    };\n\n    /**\n     * Check the type of a value.  Is it an \"array\"?\n     *\n     * @param value value to test.\n     * @returns true if the value is an array or associated with an `ArrayBuffer`\n     */\n    qq.isArray = function(value) {\n        return Object.prototype.toString.call(value) === \"[object Array]\" ||\n            (value && window.ArrayBuffer && value.buffer && value.buffer.constructor === ArrayBuffer);\n    };\n\n    // Looks for an object on a `DataTransfer` object that is associated with drop events when utilizing the Filesystem API.\n    qq.isItemList = function(maybeItemList) {\n        return Object.prototype.toString.call(maybeItemList) === \"[object DataTransferItemList]\";\n    };\n\n    // Looks for an object on a `NodeList` or an `HTMLCollection`|`HTMLFormElement`|`HTMLSelectElement`\n    // object that is associated with collections of Nodes.\n    qq.isNodeList = function(maybeNodeList) {\n        return Object.prototype.toString.call(maybeNodeList) === \"[object NodeList]\" ||\n            // If `HTMLCollection` is the actual type of the object, we must determine this\n            // by checking for expected properties/methods on the object\n            (maybeNodeList.item && maybeNodeList.namedItem);\n    };\n\n    qq.isString = function(maybeString) {\n        return Object.prototype.toString.call(maybeString) === \"[object String]\";\n    };\n\n    qq.trimStr = function(string) {\n        if (String.prototype.trim) {\n            return string.trim();\n        }\n\n        return string.replace(/^\\s+|\\s+$/g, \"\");\n    };\n\n    /**\n     * @param str String to format.\n     * @returns {string} A string, swapping argument values with the associated occurrence of {} in the passed string.\n     */\n    qq.format = function(str) {\n\n        var args =  Array.prototype.slice.call(arguments, 1),\n            newStr = str,\n            nextIdxToReplace = newStr.indexOf(\"{}\");\n\n        qq.each(args, function(idx, val) {\n            var strBefore = newStr.substring(0, nextIdxToReplace),\n                strAfter = newStr.substring(nextIdxToReplace + 2);\n\n            newStr = strBefore + val + strAfter;\n            nextIdxToReplace = newStr.indexOf(\"{}\", nextIdxToReplace + val.length);\n\n            // End the loop if we have run out of tokens (when the arguments exceed the # of tokens)\n            if (nextIdxToReplace < 0) {\n                return false;\n            }\n        });\n\n        return newStr;\n    };\n\n    qq.isFile = function(maybeFile) {\n        return window.File && Object.prototype.toString.call(maybeFile) === \"[object File]\";\n    };\n\n    qq.isFileList = function(maybeFileList) {\n        return window.FileList && Object.prototype.toString.call(maybeFileList) === \"[object FileList]\";\n    };\n\n    qq.isFileOrInput = function(maybeFileOrInput) {\n        return qq.isFile(maybeFileOrInput) || qq.isInput(maybeFileOrInput);\n    };\n\n    qq.isInput = function(maybeInput, notFile) {\n        var evaluateType = function(type) {\n            var normalizedType = type.toLowerCase();\n\n            if (notFile) {\n                return normalizedType !== \"file\";\n            }\n\n            return normalizedType === \"file\";\n        };\n\n        if (window.HTMLInputElement) {\n            if (Object.prototype.toString.call(maybeInput) === \"[object HTMLInputElement]\") {\n                if (maybeInput.type && evaluateType(maybeInput.type)) {\n                    return true;\n                }\n            }\n        }\n        if (maybeInput.tagName) {\n            if (maybeInput.tagName.toLowerCase() === \"input\") {\n                if (maybeInput.type && evaluateType(maybeInput.type)) {\n                    return true;\n                }\n            }\n        }\n\n        return false;\n    };\n\n    qq.isBlob = function(maybeBlob) {\n        if (window.Blob && Object.prototype.toString.call(maybeBlob) === \"[object Blob]\") {\n            return true;\n        }\n    };\n\n    qq.isXhrUploadSupported = function() {\n        var input = document.createElement(\"input\");\n        input.type = \"file\";\n\n        return (\n            input.multiple !== undefined &&\n                typeof File !== \"undefined\" &&\n                typeof FormData !== \"undefined\" &&\n                typeof (qq.createXhrInstance()).upload !== \"undefined\");\n    };\n\n    // Fall back to ActiveX is native XHR is disabled (possible in any version of IE).\n    qq.createXhrInstance = function() {\n        if (window.XMLHttpRequest) {\n            return new XMLHttpRequest();\n        }\n\n        try {\n            return new ActiveXObject(\"MSXML2.XMLHTTP.3.0\");\n        }\n        catch (error) {\n            qq.log(\"Neither XHR or ActiveX are supported!\", \"error\");\n            return null;\n        }\n    };\n\n    qq.isFolderDropSupported = function(dataTransfer) {\n        return dataTransfer.items &&\n            dataTransfer.items.length > 0 &&\n            dataTransfer.items[0].webkitGetAsEntry;\n    };\n\n    qq.isFileChunkingSupported = function() {\n        return !qq.androidStock() && //Android's stock browser cannot upload Blobs correctly\n            qq.isXhrUploadSupported() &&\n            (File.prototype.slice !== undefined || File.prototype.webkitSlice !== undefined || File.prototype.mozSlice !== undefined);\n    };\n\n    qq.sliceBlob = function(fileOrBlob, start, end) {\n        var slicer = fileOrBlob.slice || fileOrBlob.mozSlice || fileOrBlob.webkitSlice;\n\n        return slicer.call(fileOrBlob, start, end);\n    };\n\n    qq.arrayBufferToHex = function(buffer) {\n        var bytesAsHex = \"\",\n            bytes = new Uint8Array(buffer);\n\n        qq.each(bytes, function(idx, byt) {\n            var byteAsHexStr = byt.toString(16);\n\n            if (byteAsHexStr.length < 2) {\n                byteAsHexStr = \"0\" + byteAsHexStr;\n            }\n\n            bytesAsHex += byteAsHexStr;\n        });\n\n        return bytesAsHex;\n    };\n\n    qq.readBlobToHex = function(blob, startOffset, length) {\n        var initialBlob = qq.sliceBlob(blob, startOffset, startOffset + length),\n            fileReader = new FileReader(),\n            promise = new qq.Promise();\n\n        fileReader.onload = function() {\n            promise.success(qq.arrayBufferToHex(fileReader.result));\n        };\n\n        fileReader.onerror = promise.failure;\n\n        fileReader.readAsArrayBuffer(initialBlob);\n\n        return promise;\n    };\n\n    qq.extend = function(first, second, extendNested) {\n        qq.each(second, function(prop, val) {\n            if (extendNested && qq.isObject(val)) {\n                if (first[prop] === undefined) {\n                    first[prop] = {};\n                }\n                qq.extend(first[prop], val, true);\n            }\n            else {\n                first[prop] = val;\n            }\n        });\n\n        return first;\n    };\n\n    /**\n     * Allow properties in one object to override properties in another,\n     * keeping track of the original values from the target object.\n     *\n     * Note that the pre-overriden properties to be overriden by the source will be passed into the `sourceFn` when it is invoked.\n     *\n     * @param target Update properties in this object from some source\n     * @param sourceFn A function that, when invoked, will return properties that will replace properties with the same name in the target.\n     * @returns {object} The target object\n     */\n    qq.override = function(target, sourceFn) {\n        var super_ = {},\n            source = sourceFn(super_);\n\n        qq.each(source, function(srcPropName, srcPropVal) {\n            if (target[srcPropName] !== undefined) {\n                super_[srcPropName] = target[srcPropName];\n            }\n\n            target[srcPropName] = srcPropVal;\n        });\n\n        return target;\n    };\n\n    /**\n     * Searches for a given element (elt) in the array, returns -1 if it is not present.\n     */\n    qq.indexOf = function(arr, elt, from) {\n        if (arr.indexOf) {\n            return arr.indexOf(elt, from);\n        }\n\n        from = from || 0;\n        var len = arr.length;\n\n        if (from < 0) {\n            from += len;\n        }\n\n        for (; from < len; from += 1) {\n            if (arr.hasOwnProperty(from) && arr[from] === elt) {\n                return from;\n            }\n        }\n        return -1;\n    };\n\n    //this is a version 4 UUID\n    qq.getUniqueId = function() {\n        return \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".replace(/[xy]/g, function(c) {\n            /*jslint eqeq: true, bitwise: true*/\n            var r = Math.random() * 16 | 0, v = c == \"x\" ? r : (r & 0x3 | 0x8);\n            return v.toString(16);\n        });\n    };\n\n    //\n    // Browsers and platforms detection\n    qq.ie = function() {\n        return navigator.userAgent.indexOf(\"MSIE\") !== -1 ||\n            navigator.userAgent.indexOf(\"Trident\") !== -1;\n    };\n\n    qq.ie7 = function() {\n        return navigator.userAgent.indexOf(\"MSIE 7\") !== -1;\n    };\n\n    qq.ie8 = function() {\n        return navigator.userAgent.indexOf(\"MSIE 8\") !== -1;\n    };\n\n    qq.ie10 = function() {\n        return navigator.userAgent.indexOf(\"MSIE 10\") !== -1;\n    };\n\n    qq.ie11 = function() {\n        return qq.ie() && navigator.userAgent.indexOf(\"rv:11\") !== -1;\n    };\n\n    qq.edge = function() {\n        return navigator.userAgent.indexOf(\"Edge\") >= 0;\n    };\n\n    qq.safari = function() {\n        return navigator.vendor !== undefined && navigator.vendor.indexOf(\"Apple\") !== -1;\n    };\n\n    qq.chrome = function() {\n        return navigator.vendor !== undefined && navigator.vendor.indexOf(\"Google\") !== -1;\n    };\n\n    qq.opera = function() {\n        return navigator.vendor !== undefined && navigator.vendor.indexOf(\"Opera\") !== -1;\n    };\n\n    qq.firefox = function() {\n        return (!qq.edge() && !qq.ie11() && navigator.userAgent.indexOf(\"Mozilla\") !== -1 && navigator.vendor !== undefined && navigator.vendor === \"\");\n    };\n\n    qq.windows = function() {\n        return navigator.platform === \"Win32\";\n    };\n\n    qq.android = function() {\n        return navigator.userAgent.toLowerCase().indexOf(\"android\") !== -1;\n    };\n\n    // We need to identify the Android stock browser via the UA string to work around various bugs in this browser,\n    // such as the one that prevents a `Blob` from being uploaded.\n    qq.androidStock = function() {\n        return qq.android() && navigator.userAgent.toLowerCase().indexOf(\"chrome\") < 0;\n    };\n\n    qq.ios6 = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\" OS 6_\") !== -1;\n    };\n\n    qq.ios7 = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\" OS 7_\") !== -1;\n    };\n\n    qq.ios8 = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\" OS 8_\") !== -1;\n    };\n\n    // iOS 8.0.0\n    qq.ios800 = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\" OS 8_0 \") !== -1;\n    };\n\n    qq.ios = function() {\n        /*jshint -W014 */\n        return navigator.userAgent.indexOf(\"iPad\") !== -1\n            || navigator.userAgent.indexOf(\"iPod\") !== -1\n            || navigator.userAgent.indexOf(\"iPhone\") !== -1;\n    };\n\n    qq.iosChrome = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\"CriOS\") !== -1;\n    };\n\n    qq.iosSafari = function() {\n        return qq.ios() && !qq.iosChrome() && navigator.userAgent.indexOf(\"Safari\") !== -1;\n    };\n\n    qq.iosSafariWebView = function() {\n        return qq.ios() && !qq.iosChrome() && !qq.iosSafari();\n    };\n\n    //\n    // Events\n\n    qq.preventDefault = function(e) {\n        if (e.preventDefault) {\n            e.preventDefault();\n        } else {\n            e.returnValue = false;\n        }\n    };\n\n    /**\n     * Creates and returns element from html string\n     * Uses innerHTML to create an element\n     */\n    qq.toElement = (function() {\n        var div = document.createElement(\"div\");\n        return function(html) {\n            div.innerHTML = html;\n            var element = div.firstChild;\n            div.removeChild(element);\n            return element;\n        };\n    }());\n\n    //key and value are passed to callback for each entry in the iterable item\n    qq.each = function(iterableItem, callback) {\n        var keyOrIndex, retVal;\n\n        if (iterableItem) {\n            // Iterate through [`Storage`](http://www.w3.org/TR/webstorage/#the-storage-interface) items\n            if (window.Storage && iterableItem.constructor === window.Storage) {\n                for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {\n                    retVal = callback(iterableItem.key(keyOrIndex), iterableItem.getItem(iterableItem.key(keyOrIndex)));\n                    if (retVal === false) {\n                        break;\n                    }\n                }\n            }\n            // `DataTransferItemList` & `NodeList` objects are array-like and should be treated as arrays\n            // when iterating over items inside the object.\n            else if (qq.isArray(iterableItem) || qq.isItemList(iterableItem) || qq.isNodeList(iterableItem)) {\n                for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {\n                    retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);\n                    if (retVal === false) {\n                        break;\n                    }\n                }\n            }\n            else if (qq.isString(iterableItem)) {\n                for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {\n                    retVal = callback(keyOrIndex, iterableItem.charAt(keyOrIndex));\n                    if (retVal === false) {\n                        break;\n                    }\n                }\n            }\n            else {\n                for (keyOrIndex in iterableItem) {\n                    if (Object.prototype.hasOwnProperty.call(iterableItem, keyOrIndex)) {\n                        retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);\n                        if (retVal === false) {\n                            break;\n                        }\n                    }\n                }\n            }\n        }\n    };\n\n    //include any args that should be passed to the new function after the context arg\n    qq.bind = function(oldFunc, context) {\n        if (qq.isFunction(oldFunc)) {\n            var args =  Array.prototype.slice.call(arguments, 2);\n\n            return function() {\n                var newArgs = qq.extend([], args);\n                if (arguments.length) {\n                    newArgs = newArgs.concat(Array.prototype.slice.call(arguments));\n                }\n                return oldFunc.apply(context, newArgs);\n            };\n        }\n\n        throw new Error(\"first parameter must be a function!\");\n    };\n\n    /**\n     * obj2url() takes a json-object as argument and generates\n     * a querystring. pretty much like jQuery.param()\n     *\n     * how to use:\n     *\n     *    `qq.obj2url({a:'b',c:'d'},'http://any.url/upload?otherParam=value');`\n     *\n     * will result in:\n     *\n     *    `http://any.url/upload?otherParam=value&a=b&c=d`\n     *\n     * @param  Object JSON-Object\n     * @param  String current querystring-part\n     * @return String encoded querystring\n     */\n    qq.obj2url = function(obj, temp, prefixDone) {\n        /*jshint laxbreak: true*/\n        var uristrings = [],\n            prefix = \"&\",\n            add = function(nextObj, i) {\n                var nextTemp = temp\n                    ? (/\\[\\]$/.test(temp)) // prevent double-encoding\n                    ? temp\n                    : temp + \"[\" + i + \"]\"\n                    : i;\n                if ((nextTemp !== \"undefined\") && (i !== \"undefined\")) {\n                    uristrings.push(\n                        (typeof nextObj === \"object\")\n                            ? qq.obj2url(nextObj, nextTemp, true)\n                            : (Object.prototype.toString.call(nextObj) === \"[object Function]\")\n                            ? encodeURIComponent(nextTemp) + \"=\" + encodeURIComponent(nextObj())\n                            : encodeURIComponent(nextTemp) + \"=\" + encodeURIComponent(nextObj)\n                    );\n                }\n            };\n\n        if (!prefixDone && temp) {\n            prefix = (/\\?/.test(temp)) ? (/\\?$/.test(temp)) ? \"\" : \"&\" : \"?\";\n            uristrings.push(temp);\n            uristrings.push(qq.obj2url(obj));\n        } else if ((Object.prototype.toString.call(obj) === \"[object Array]\") && (typeof obj !== \"undefined\")) {\n            qq.each(obj, function(idx, val) {\n                add(val, idx);\n            });\n        } else if ((typeof obj !== \"undefined\") && (obj !== null) && (typeof obj === \"object\")) {\n            qq.each(obj, function(prop, val) {\n                add(val, prop);\n            });\n        } else {\n            uristrings.push(encodeURIComponent(temp) + \"=\" + encodeURIComponent(obj));\n        }\n\n        if (temp) {\n            return uristrings.join(prefix);\n        } else {\n            return uristrings.join(prefix)\n                .replace(/^&/, \"\")\n                .replace(/%20/g, \"+\");\n        }\n    };\n\n    qq.obj2FormData = function(obj, formData, arrayKeyName) {\n        if (!formData) {\n            formData = new FormData();\n        }\n\n        qq.each(obj, function(key, val) {\n            key = arrayKeyName ? arrayKeyName + \"[\" + key + \"]\" : key;\n\n            if (qq.isObject(val)) {\n                qq.obj2FormData(val, formData, key);\n            }\n            else if (qq.isFunction(val)) {\n                formData.append(key, val());\n            }\n            else {\n                formData.append(key, val);\n            }\n        });\n\n        return formData;\n    };\n\n    qq.obj2Inputs = function(obj, form) {\n        var input;\n\n        if (!form) {\n            form = document.createElement(\"form\");\n        }\n\n        qq.obj2FormData(obj, {\n            append: function(key, val) {\n                input = document.createElement(\"input\");\n                input.setAttribute(\"name\", key);\n                input.setAttribute(\"value\", val);\n                form.appendChild(input);\n            }\n        });\n\n        return form;\n    };\n\n    /**\n     * Not recommended for use outside of Fine Uploader since this falls back to an unchecked eval if JSON.parse is not\n     * implemented.  For a more secure JSON.parse polyfill, use Douglas Crockford's json2.js.\n     */\n    qq.parseJson = function(json) {\n        /*jshint evil: true*/\n        if (window.JSON && qq.isFunction(JSON.parse)) {\n            return JSON.parse(json);\n        } else {\n            return eval(\"(\" + json + \")\");\n        }\n    };\n\n    /**\n     * Retrieve the extension of a file, if it exists.\n     *\n     * @param filename\n     * @returns {string || undefined}\n     */\n    qq.getExtension = function(filename) {\n        var extIdx = filename.lastIndexOf(\".\") + 1;\n\n        if (extIdx > 0) {\n            return filename.substr(extIdx, filename.length - extIdx);\n        }\n    };\n\n    qq.getFilename = function(blobOrFileInput) {\n        /*jslint regexp: true*/\n\n        if (qq.isInput(blobOrFileInput)) {\n            // get input value and remove path to normalize\n            return blobOrFileInput.value.replace(/.*(\\/|\\\\)/, \"\");\n        }\n        else if (qq.isFile(blobOrFileInput)) {\n            if (blobOrFileInput.fileName !== null && blobOrFileInput.fileName !== undefined) {\n                return blobOrFileInput.fileName;\n            }\n        }\n\n        return blobOrFileInput.name;\n    };\n\n    /**\n     * A generic module which supports object disposing in dispose() method.\n     * */\n    qq.DisposeSupport = function() {\n        var disposers = [];\n\n        return {\n            /** Run all registered disposers */\n            dispose: function() {\n                var disposer;\n                do {\n                    disposer = disposers.shift();\n                    if (disposer) {\n                        disposer();\n                    }\n                }\n                while (disposer);\n            },\n\n            /** Attach event handler and register de-attacher as a disposer */\n            attach: function() {\n                var args = arguments;\n                /*jslint undef:true*/\n                this.addDisposer(qq(args[0]).attach.apply(this, Array.prototype.slice.call(arguments, 1)));\n            },\n\n            /** Add disposer to the collection */\n            addDisposer: function(disposeFunction) {\n                disposers.push(disposeFunction);\n            }\n        };\n    };\n}());\n","/* globals define, module, global, qq */\n(function() {\n    \"use strict\";\n    if (typeof define === \"function\" && define.amd) {\n        define(function() {\n            return qq;\n        });\n    }\n    else if (typeof module !== \"undefined\" && module.exports) {\n        module.exports = qq;\n    }\n    else {\n        global.qq = qq;\n    }\n}());\n","/* globals qq */\n/**\n * Fine Uploader top-level Error container.  Inherits from `Error`.\n */\n(function() {\n    \"use strict\";\n\n    qq.Error = function(message) {\n        this.message = \"[Fine Uploader \" + qq.version + \"] \" + message;\n    };\n\n    qq.Error.prototype = new Error();\n}());\n","/*global qq */\nqq.version = \"5.16.2\";\n","/* globals qq */\nqq.supportedFeatures = (function() {\n    \"use strict\";\n\n    var supportsUploading,\n        supportsUploadingBlobs,\n        supportsFileDrop,\n        supportsAjaxFileUploading,\n        supportsFolderDrop,\n        supportsChunking,\n        supportsResume,\n        supportsUploadViaPaste,\n        supportsUploadCors,\n        supportsDeleteFileXdr,\n        supportsDeleteFileCorsXhr,\n        supportsDeleteFileCors,\n        supportsFolderSelection,\n        supportsImagePreviews,\n        supportsUploadProgress;\n\n    function testSupportsFileInputElement() {\n        var supported = true,\n            tempInput;\n\n        try {\n            tempInput = document.createElement(\"input\");\n            tempInput.type = \"file\";\n            qq(tempInput).hide();\n\n            if (tempInput.disabled) {\n                supported = false;\n            }\n        }\n        catch (ex) {\n            supported = false;\n        }\n\n        return supported;\n    }\n\n    //only way to test for complete Clipboard API support at this time\n    function isChrome14OrHigher() {\n        return (qq.chrome() || qq.opera()) &&\n            navigator.userAgent.match(/Chrome\\/[1][4-9]|Chrome\\/[2-9][0-9]/) !== undefined;\n    }\n\n    //Ensure we can send cross-origin `XMLHttpRequest`s\n    function isCrossOriginXhrSupported() {\n        if (window.XMLHttpRequest) {\n            var xhr = qq.createXhrInstance();\n\n            //Commonly accepted test for XHR CORS support.\n            return xhr.withCredentials !== undefined;\n        }\n\n        return false;\n    }\n\n    //Test for (terrible) cross-origin ajax transport fallback for IE9 and IE8\n    function isXdrSupported() {\n        return window.XDomainRequest !== undefined;\n    }\n\n    // CORS Ajax requests are supported if it is either possible to send credentialed `XMLHttpRequest`s,\n    // or if `XDomainRequest` is an available alternative.\n    function isCrossOriginAjaxSupported() {\n        if (isCrossOriginXhrSupported()) {\n            return true;\n        }\n\n        return isXdrSupported();\n    }\n\n    function isFolderSelectionSupported() {\n        // We know that folder selection is only supported in Chrome via this proprietary attribute for now\n        return document.createElement(\"input\").webkitdirectory !== undefined;\n    }\n\n    function isLocalStorageSupported() {\n        try {\n            return !!window.localStorage &&\n                // unpatched versions of IE10/11 have buggy impls of localStorage where setItem is a string\n                qq.isFunction(window.localStorage.setItem);\n        }\n        catch (error) {\n            // probably caught a security exception, so no localStorage for you\n            return false;\n        }\n    }\n\n    function isDragAndDropSupported() {\n        var span = document.createElement(\"span\");\n\n        return (\"draggable\" in span || (\"ondragstart\" in span && \"ondrop\" in span)) &&\n            !qq.android() && !qq.ios();\n    }\n\n    supportsUploading = testSupportsFileInputElement();\n\n    supportsAjaxFileUploading = supportsUploading && qq.isXhrUploadSupported();\n\n    supportsUploadingBlobs = supportsAjaxFileUploading && !qq.androidStock();\n\n    supportsFileDrop = supportsAjaxFileUploading && isDragAndDropSupported();\n\n    // adapted from https://stackoverflow.com/a/23278460/486979\n    supportsFolderDrop = supportsFileDrop && (function() {\n        var input = document.createElement(\"input\");\n\n        input.type = \"file\";\n        return !!(\"webkitdirectory\" in (input || document.querySelectorAll(\"input[type=file]\")[0]));\n    }());\n\n    supportsChunking = supportsAjaxFileUploading && qq.isFileChunkingSupported();\n\n    supportsResume = supportsAjaxFileUploading && supportsChunking && isLocalStorageSupported();\n\n    supportsUploadViaPaste = supportsAjaxFileUploading && isChrome14OrHigher();\n\n    supportsUploadCors = supportsUploading && (window.postMessage !== undefined || supportsAjaxFileUploading);\n\n    supportsDeleteFileCorsXhr = isCrossOriginXhrSupported();\n\n    supportsDeleteFileXdr = isXdrSupported();\n\n    supportsDeleteFileCors = isCrossOriginAjaxSupported();\n\n    supportsFolderSelection = isFolderSelectionSupported();\n\n    supportsImagePreviews = supportsAjaxFileUploading && window.FileReader !== undefined;\n\n    supportsUploadProgress = (function() {\n        if (supportsAjaxFileUploading) {\n            return !qq.androidStock() && !qq.iosChrome();\n        }\n        return false;\n    }());\n\n    return {\n        ajaxUploading: supportsAjaxFileUploading,\n        blobUploading: supportsUploadingBlobs,\n        canDetermineSize: supportsAjaxFileUploading,\n        chunking: supportsChunking,\n        deleteFileCors: supportsDeleteFileCors,\n        deleteFileCorsXdr: supportsDeleteFileXdr, //NOTE: will also return true in IE10, where XDR is also supported\n        deleteFileCorsXhr: supportsDeleteFileCorsXhr,\n        dialogElement: !!window.HTMLDialogElement,\n        fileDrop: supportsFileDrop,\n        folderDrop: supportsFolderDrop,\n        folderSelection: supportsFolderSelection,\n        imagePreviews: supportsImagePreviews,\n        imageValidation: supportsImagePreviews,\n        itemSizeValidation: supportsAjaxFileUploading,\n        pause: supportsChunking,\n        progressBar: supportsUploadProgress,\n        resume: supportsResume,\n        scaling: supportsImagePreviews && supportsUploadingBlobs,\n        tiffPreviews: qq.safari(), // Not the best solution, but simple and probably accurate enough (for now)\n        unlimitedScaledImageSize: !qq.ios(), // false simply indicates that there is some known limit\n        uploading: supportsUploading,\n        uploadCors: supportsUploadCors,\n        uploadCustomHeaders: supportsAjaxFileUploading,\n        uploadNonMultipart: supportsAjaxFileUploading,\n        uploadViaPaste: supportsUploadViaPaste\n    };\n\n}());\n","/*globals qq*/\n\n// Is the passed object a promise instance?\nqq.isGenericPromise = function(maybePromise) {\n    \"use strict\";\n    return !!(maybePromise && maybePromise.then && qq.isFunction(maybePromise.then));\n};\n\nqq.Promise = function() {\n    \"use strict\";\n\n    var successArgs, failureArgs,\n        successCallbacks = [],\n        failureCallbacks = [],\n        doneCallbacks = [],\n        state = 0;\n\n    qq.extend(this, {\n        then: function(onSuccess, onFailure) {\n            if (state === 0) {\n                if (onSuccess) {\n                    successCallbacks.push(onSuccess);\n                }\n                if (onFailure) {\n                    failureCallbacks.push(onFailure);\n                }\n            }\n            else if (state === -1) {\n                onFailure && onFailure.apply(null, failureArgs);\n            }\n            else if (onSuccess) {\n                onSuccess.apply(null, successArgs);\n            }\n\n            return this;\n        },\n\n        done: function(callback) {\n            if (state === 0) {\n                doneCallbacks.push(callback);\n            }\n            else {\n                callback.apply(null, failureArgs === undefined ? successArgs : failureArgs);\n            }\n\n            return this;\n        },\n\n        success: function() {\n            state = 1;\n            successArgs = arguments;\n\n            if (successCallbacks.length) {\n                qq.each(successCallbacks, function(idx, callback) {\n                    callback.apply(null, successArgs);\n                });\n            }\n\n            if (doneCallbacks.length) {\n                qq.each(doneCallbacks, function(idx, callback) {\n                    callback.apply(null, successArgs);\n                });\n            }\n\n            return this;\n        },\n\n        failure: function() {\n            state = -1;\n            failureArgs = arguments;\n\n            if (failureCallbacks.length) {\n                qq.each(failureCallbacks, function(idx, callback) {\n                    callback.apply(null, failureArgs);\n                });\n            }\n\n            if (doneCallbacks.length) {\n                qq.each(doneCallbacks, function(idx, callback) {\n                    callback.apply(null, failureArgs);\n                });\n            }\n\n            return this;\n        }\n    });\n};\n","/* globals qq */\n/**\n * Placeholder for a Blob that will be generated on-demand.\n *\n * @param referenceBlob Parent of the generated blob\n * @param onCreate Function to invoke when the blob must be created.  Must be promissory.\n * @constructor\n */\nqq.BlobProxy = function(referenceBlob, onCreate) {\n    \"use strict\";\n\n    qq.extend(this, {\n        referenceBlob: referenceBlob,\n\n        create: function() {\n            return onCreate(referenceBlob);\n        }\n    });\n};\n","/*globals qq*/\n\n/**\n * This module represents an upload or \"Select File(s)\" button.  It's job is to embed an opaque `<input type=\"file\">`\n * element as a child of a provided \"container\" element.  This \"container\" element (`options.element`) is used to provide\n * a custom style for the `<input type=\"file\">` element.  The ability to change the style of the container element is also\n * provided here by adding CSS classes to the container on hover/focus.\n *\n * TODO Eliminate the mouseover and mouseout event handlers since the :hover CSS pseudo-class should now be\n * available on all supported browsers.\n *\n * @param o Options to override the default values\n */\nqq.UploadButton = function(o) {\n    \"use strict\";\n\n    var self = this,\n\n        disposeSupport = new qq.DisposeSupport(),\n\n        options = {\n            // Corresponds to the `accept` attribute on the associated `<input type=\"file\">`\n            acceptFiles: null,\n\n            // \"Container\" element\n            element: null,\n\n            focusClass: \"qq-upload-button-focus\",\n\n            // A true value allows folders to be selected, if supported by the UA\n            folders: false,\n\n            // **This option will be removed** in the future as the :hover CSS pseudo-class is available on all supported browsers\n            hoverClass: \"qq-upload-button-hover\",\n\n            ios8BrowserCrashWorkaround: false,\n\n            // If true adds `multiple` attribute to `<input type=\"file\">`\n            multiple: false,\n\n            // `name` attribute of `<input type=\"file\">`\n            name: \"qqfile\",\n\n            // Called when the browser invokes the onchange handler on the `<input type=\"file\">`\n            onChange: function(input) {},\n\n            title: null\n        },\n        input, buttonId;\n\n    // Overrides any of the default option values with any option values passed in during construction.\n    qq.extend(options, o);\n\n    buttonId = qq.getUniqueId();\n\n    // Embed an opaque `<input type=\"file\">` element as a child of `options.element`.\n    function createInput() {\n        var input = document.createElement(\"input\");\n\n        input.setAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME, buttonId);\n        input.setAttribute(\"title\", options.title);\n\n        self.setMultiple(options.multiple, input);\n\n        if (options.folders && qq.supportedFeatures.folderSelection) {\n            // selecting directories is only possible in Chrome now, via a vendor-specific prefixed attribute\n            input.setAttribute(\"webkitdirectory\", \"\");\n        }\n\n        if (options.acceptFiles) {\n            input.setAttribute(\"accept\", options.acceptFiles);\n        }\n\n        input.setAttribute(\"type\", \"file\");\n        input.setAttribute(\"name\", options.name);\n\n        qq(input).css({\n            position: \"absolute\",\n            // in Opera only 'browse' button\n            // is clickable and it is located at\n            // the right side of the input\n            right: 0,\n            top: 0,\n            fontFamily: \"Arial\",\n            // It's especially important to make this an arbitrarily large value\n            // to ensure the rendered input button in IE takes up the entire\n            // space of the container element.  Otherwise, the left side of the\n            // button will require a double-click to invoke the file chooser.\n            // In other browsers, this might cause other issues, so a large font-size\n            // is only used in IE.  There is a bug in IE8 where the opacity style is  ignored\n            // in some cases when the font-size is large.  So, this workaround is not applied\n            // to IE8.\n            fontSize: qq.ie() && !qq.ie8() ? \"3500px\" : \"118px\",\n            margin: 0,\n            padding: 0,\n            cursor: \"pointer\",\n            opacity: 0\n        });\n\n        // Setting the file input's height to 100% in IE7 causes\n        // most of the visible button to be unclickable.\n        !qq.ie7() && qq(input).css({height: \"100%\"});\n\n        options.element.appendChild(input);\n\n        disposeSupport.attach(input, \"change\", function() {\n            options.onChange(input);\n        });\n\n        // **These event handlers will be removed** in the future as the :hover CSS pseudo-class is available on all supported browsers\n        disposeSupport.attach(input, \"mouseover\", function() {\n            qq(options.element).addClass(options.hoverClass);\n        });\n        disposeSupport.attach(input, \"mouseout\", function() {\n            qq(options.element).removeClass(options.hoverClass);\n        });\n\n        disposeSupport.attach(input, \"focus\", function() {\n            qq(options.element).addClass(options.focusClass);\n        });\n        disposeSupport.attach(input, \"blur\", function() {\n            qq(options.element).removeClass(options.focusClass);\n        });\n\n        return input;\n    }\n\n    // Make button suitable container for input\n    qq(options.element).css({\n        position: \"relative\",\n        overflow: \"hidden\",\n        // Make sure browse button is in the right side in Internet Explorer\n        direction: \"ltr\"\n    });\n\n    // Exposed API\n    qq.extend(this, {\n        getInput: function() {\n            return input;\n        },\n\n        getButtonId: function() {\n            return buttonId;\n        },\n\n        setMultiple: function(isMultiple, optInput) {\n            var input = optInput || this.getInput();\n\n            // Temporary workaround for bug in in iOS8 UIWebView that causes the browser to crash\n            // before the file chooser appears if the file input doesn't contain a multiple attribute.\n            // See #1283.\n            if (options.ios8BrowserCrashWorkaround && qq.ios8() && (qq.iosChrome() || qq.iosSafariWebView())) {\n                input.setAttribute(\"multiple\", \"\");\n            }\n\n            else {\n                if (isMultiple) {\n                    input.setAttribute(\"multiple\", \"\");\n                }\n                else {\n                    input.removeAttribute(\"multiple\");\n                }\n            }\n        },\n\n        setAcceptFiles: function(acceptFiles) {\n            if (acceptFiles !== options.acceptFiles) {\n                input.setAttribute(\"accept\", acceptFiles);\n            }\n        },\n\n        reset: function() {\n            if (input.parentNode) {\n                qq(input).remove();\n            }\n\n            qq(options.element).removeClass(options.focusClass);\n            input = null;\n            input = createInput();\n        }\n    });\n\n    input = createInput();\n};\n\nqq.UploadButton.BUTTON_ID_ATTR_NAME = \"qq-button-id\";\n","/*globals qq */\nqq.UploadData = function(uploaderProxy) {\n    \"use strict\";\n\n    var data = [],\n        byUuid = {},\n        byStatus = {},\n        byProxyGroupId = {},\n        byBatchId = {};\n\n    function getDataByIds(idOrIds) {\n        if (qq.isArray(idOrIds)) {\n            var entries = [];\n\n            qq.each(idOrIds, function(idx, id) {\n                entries.push(data[id]);\n            });\n\n            return entries;\n        }\n\n        return data[idOrIds];\n    }\n\n    function getDataByUuids(uuids) {\n        if (qq.isArray(uuids)) {\n            var entries = [];\n\n            qq.each(uuids, function(idx, uuid) {\n                entries.push(data[byUuid[uuid]]);\n            });\n\n            return entries;\n        }\n\n        return data[byUuid[uuids]];\n    }\n\n    function getDataByStatus(status) {\n        var statusResults = [],\n            statuses = [].concat(status);\n\n        qq.each(statuses, function(index, statusEnum) {\n            var statusResultIndexes = byStatus[statusEnum];\n\n            if (statusResultIndexes !== undefined) {\n                qq.each(statusResultIndexes, function(i, dataIndex) {\n                    statusResults.push(data[dataIndex]);\n                });\n            }\n        });\n\n        return statusResults;\n    }\n\n    qq.extend(this, {\n        /**\n         * Adds a new file to the data cache for tracking purposes.\n         *\n         * @param spec Data that describes this file.  Possible properties are:\n         *\n         * - uuid: Initial UUID for this file.\n         * - name: Initial name of this file.\n         * - size: Size of this file, omit if this cannot be determined\n         * - status: Initial `qq.status` for this file.  Omit for `qq.status.SUBMITTING`.\n         * - batchId: ID of the batch this file belongs to\n         * - proxyGroupId: ID of the proxy group associated with this file\n         * - onBeforeStatusChange(fileId): callback that is executed before the status change is broadcast\n         *\n         * @returns {number} Internal ID for this file.\n         */\n        addFile: function(spec) {\n            var status = spec.status || qq.status.SUBMITTING,\n                id = data.push({\n                    name: spec.name,\n                    originalName: spec.name,\n                    uuid: spec.uuid,\n                    size: spec.size == null ? -1 : spec.size,\n                    status: status,\n                    file: spec.file\n                }) - 1;\n\n            if (spec.batchId) {\n                data[id].batchId = spec.batchId;\n\n                if (byBatchId[spec.batchId] === undefined) {\n                    byBatchId[spec.batchId] = [];\n                }\n                byBatchId[spec.batchId].push(id);\n            }\n\n            if (spec.proxyGroupId) {\n                data[id].proxyGroupId = spec.proxyGroupId;\n\n                if (byProxyGroupId[spec.proxyGroupId] === undefined) {\n                    byProxyGroupId[spec.proxyGroupId] = [];\n                }\n                byProxyGroupId[spec.proxyGroupId].push(id);\n            }\n\n            data[id].id = id;\n            byUuid[spec.uuid] = id;\n\n            if (byStatus[status] === undefined) {\n                byStatus[status] = [];\n            }\n            byStatus[status].push(id);\n\n            spec.onBeforeStatusChange && spec.onBeforeStatusChange(id);\n            uploaderProxy.onStatusChange(id, null, status);\n\n            return id;\n        },\n\n        retrieve: function(optionalFilter) {\n            if (qq.isObject(optionalFilter) && data.length)  {\n                if (optionalFilter.id !== undefined) {\n                    return getDataByIds(optionalFilter.id);\n                }\n\n                else if (optionalFilter.uuid !== undefined) {\n                    return getDataByUuids(optionalFilter.uuid);\n                }\n\n                else if (optionalFilter.status) {\n                    return getDataByStatus(optionalFilter.status);\n                }\n            }\n            else {\n                return qq.extend([], data, true);\n            }\n        },\n\n        removeFileRef: function(id) {\n            var record = getDataByIds(id);\n\n            if (record) {\n                delete record.file;\n            }\n        },\n\n        reset: function() {\n            data = [];\n            byUuid = {};\n            byStatus = {};\n            byBatchId = {};\n        },\n\n        setStatus: function(id, newStatus) {\n            var oldStatus = data[id].status,\n                byStatusOldStatusIndex = qq.indexOf(byStatus[oldStatus], id);\n\n            byStatus[oldStatus].splice(byStatusOldStatusIndex, 1);\n\n            data[id].status = newStatus;\n\n            if (byStatus[newStatus] === undefined) {\n                byStatus[newStatus] = [];\n            }\n            byStatus[newStatus].push(id);\n\n            uploaderProxy.onStatusChange(id, oldStatus, newStatus);\n        },\n\n        uuidChanged: function(id, newUuid) {\n            var oldUuid = data[id].uuid;\n\n            data[id].uuid = newUuid;\n            byUuid[newUuid] = id;\n            delete byUuid[oldUuid];\n        },\n\n        updateName: function(id, newName) {\n            data[id].name = newName;\n        },\n\n        updateSize: function(id, newSize) {\n            data[id].size = newSize;\n        },\n\n        // Only applicable if this file has a parent that we may want to reference later.\n        setParentId: function(targetId, parentId) {\n            data[targetId].parentId = parentId;\n        },\n\n        getIdsInProxyGroup: function(id) {\n            var proxyGroupId = data[id].proxyGroupId;\n\n            if (proxyGroupId) {\n                return byProxyGroupId[proxyGroupId];\n            }\n            return [];\n        },\n\n        getIdsInBatch: function(id) {\n            var batchId = data[id].batchId;\n\n            return byBatchId[batchId];\n        }\n    });\n};\n\nqq.status = {\n    SUBMITTING: \"submitting\",\n    SUBMITTED: \"submitted\",\n    REJECTED: \"rejected\",\n    QUEUED: \"queued\",\n    CANCELED: \"canceled\",\n    PAUSED: \"paused\",\n    UPLOADING: \"uploading\",\n    UPLOAD_FINALIZING: \"upload finalizing\",\n    UPLOAD_RETRYING: \"retrying upload\",\n    UPLOAD_SUCCESSFUL: \"upload successful\",\n    UPLOAD_FAILED: \"upload failed\",\n    DELETE_FAILED: \"delete failed\",\n    DELETING: \"deleting\",\n    DELETED: \"deleted\"\n};\n","/*globals qq*/\n/**\n * Defines the public API for FineUploaderBasic mode.\n */\n(function() {\n    \"use strict\";\n\n    qq.basePublicApi = {\n        // DEPRECATED - TODO REMOVE IN NEXT MAJOR RELEASE (replaced by addFiles)\n        addBlobs: function(blobDataOrArray, params, endpoint) {\n            this.addFiles(blobDataOrArray, params, endpoint);\n        },\n\n        addInitialFiles: function(cannedFileList) {\n            var self = this;\n\n            qq.each(cannedFileList, function(index, cannedFile) {\n                self._addCannedFile(cannedFile);\n            });\n        },\n\n        addFiles: function(data, params, endpoint) {\n            this._maybeHandleIos8SafariWorkaround();\n\n            var batchId = this._storedIds.length === 0 ? qq.getUniqueId() : this._currentBatchId,\n\n                processBlob = qq.bind(function(blob) {\n                    this._handleNewFile({\n                        blob: blob,\n                        name: this._options.blobs.defaultName\n                    }, batchId, verifiedFiles);\n                }, this),\n\n                processBlobData = qq.bind(function(blobData) {\n                    this._handleNewFile(blobData, batchId, verifiedFiles);\n                }, this),\n\n                processCanvas = qq.bind(function(canvas) {\n                    var blob = qq.canvasToBlob(canvas);\n\n                    this._handleNewFile({\n                        blob: blob,\n                        name: this._options.blobs.defaultName + \".png\"\n                    }, batchId, verifiedFiles);\n                }, this),\n\n                processCanvasData = qq.bind(function(canvasData) {\n                    var normalizedQuality = canvasData.quality && canvasData.quality / 100,\n                        blob = qq.canvasToBlob(canvasData.canvas, canvasData.type, normalizedQuality);\n\n                    this._handleNewFile({\n                        blob: blob,\n                        name: canvasData.name\n                    }, batchId, verifiedFiles);\n                }, this),\n\n                processFileOrInput = qq.bind(function(fileOrInput) {\n                    if (qq.isInput(fileOrInput) && qq.supportedFeatures.ajaxUploading) {\n                        var files = Array.prototype.slice.call(fileOrInput.files),\n                            self = this;\n\n                        qq.each(files, function(idx, file) {\n                            self._handleNewFile(file, batchId, verifiedFiles);\n                        });\n                    }\n                    else {\n                        this._handleNewFile(fileOrInput, batchId, verifiedFiles);\n                    }\n                }, this),\n\n                normalizeData = function() {\n                    if (qq.isFileList(data)) {\n                        data = Array.prototype.slice.call(data);\n                    }\n                    data = [].concat(data);\n                },\n\n                self = this,\n                verifiedFiles = [];\n\n            this._currentBatchId = batchId;\n\n            if (data) {\n                normalizeData();\n\n                qq.each(data, function(idx, fileContainer) {\n                    if (qq.isFileOrInput(fileContainer)) {\n                        processFileOrInput(fileContainer);\n                    }\n                    else if (qq.isBlob(fileContainer)) {\n                        processBlob(fileContainer);\n                    }\n                    else if (qq.isObject(fileContainer)) {\n                        if (fileContainer.blob && fileContainer.name) {\n                            processBlobData(fileContainer);\n                        }\n                        else if (fileContainer.canvas && fileContainer.name) {\n                            processCanvasData(fileContainer);\n                        }\n                    }\n                    else if (fileContainer.tagName && fileContainer.tagName.toLowerCase() === \"canvas\") {\n                        processCanvas(fileContainer);\n                    }\n                    else {\n                        self.log(fileContainer + \" is not a valid file container!  Ignoring!\", \"warn\");\n                    }\n                });\n\n                this.log(\"Received \" + verifiedFiles.length + \" files.\");\n                this._prepareItemsForUpload(verifiedFiles, params, endpoint);\n            }\n        },\n\n        cancel: function(id) {\n            var uploadData = this._uploadData.retrieve({id: id});\n\n            if (uploadData && uploadData.status === qq.status.UPLOAD_FINALIZING) {\n                this.log(qq.format(\"Ignoring cancel for file ID {} ({}).  Finalizing upload.\", id, this.getName(id)), \"error\");\n            }\n            else {\n                this._handler.cancel(id);\n            }\n        },\n\n        cancelAll: function() {\n            var storedIdsCopy = [],\n                self = this;\n\n            qq.extend(storedIdsCopy, this._storedIds);\n            qq.each(storedIdsCopy, function(idx, storedFileId) {\n                self.cancel(storedFileId);\n            });\n\n            this._handler.cancelAll();\n        },\n\n        clearStoredFiles: function() {\n            this._storedIds = [];\n        },\n\n        continueUpload: function(id) {\n            var uploadData = this._uploadData.retrieve({id: id});\n\n            if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {\n                return false;\n            }\n\n            if (uploadData.status === qq.status.PAUSED) {\n                this.log(qq.format(\"Paused file ID {} ({}) will be continued.  Not paused.\", id, this.getName(id)));\n                this._uploadFile(id);\n                return true;\n            }\n            else {\n                this.log(qq.format(\"Ignoring continue for file ID {} ({}).  Not paused.\", id, this.getName(id)), \"error\");\n            }\n\n            return false;\n        },\n\n        deleteFile: function(id) {\n            return this._onSubmitDelete(id);\n        },\n\n        // TODO document?\n        doesExist: function(fileOrBlobId) {\n            return this._handler.isValid(fileOrBlobId);\n        },\n\n        // Generate a variable size thumbnail on an img or canvas,\n        // returning a promise that is fulfilled when the attempt completes.\n        // Thumbnail can either be based off of a URL for an image returned\n        // by the server in the upload response, or the associated `Blob`.\n        drawThumbnail: function(fileId, imgOrCanvas, maxSize, fromServer, customResizeFunction) {\n            var promiseToReturn = new qq.Promise(),\n                fileOrUrl, options;\n\n            if (this._imageGenerator) {\n                fileOrUrl = this._thumbnailUrls[fileId];\n                options = {\n                    customResizeFunction: customResizeFunction,\n                    maxSize: maxSize > 0 ? maxSize : null,\n                    scale: maxSize > 0\n                };\n\n                // If client-side preview generation is possible\n                // and we are not specifically looking for the image URl returned by the server...\n                if (!fromServer && qq.supportedFeatures.imagePreviews) {\n                    fileOrUrl = this.getFile(fileId);\n                }\n\n                /* jshint eqeqeq:false,eqnull:true */\n                if (fileOrUrl == null) {\n                    promiseToReturn.failure({container: imgOrCanvas, error: \"File or URL not found.\"});\n                }\n                else {\n                    this._imageGenerator.generate(fileOrUrl, imgOrCanvas, options).then(\n                        function success(modifiedContainer) {\n                            promiseToReturn.success(modifiedContainer);\n                        },\n\n                        function failure(container, reason) {\n                            promiseToReturn.failure({container: container, error: reason || \"Problem generating thumbnail\"});\n                        }\n                    );\n                }\n            }\n            else {\n                promiseToReturn.failure({container: imgOrCanvas, error: \"Missing image generator module\"});\n            }\n\n            return promiseToReturn;\n        },\n\n        getButton: function(fileId) {\n            return this._getButton(this._buttonIdsForFileIds[fileId]);\n        },\n\n        getEndpoint: function(fileId) {\n            return this._endpointStore.get(fileId);\n        },\n\n        getFile: function(fileOrBlobId) {\n            var file = this._handler.getFile(fileOrBlobId);\n            var uploadDataRecord;\n\n            if (!file) {\n                uploadDataRecord = this._uploadData.retrieve({id: fileOrBlobId});\n\n                if (uploadDataRecord) {\n                    file = uploadDataRecord.file;\n                }\n            }\n\n            return file || null;\n        },\n\n        getInProgress: function() {\n            return this._uploadData.retrieve({\n                status: [\n                    qq.status.UPLOADING,\n                    qq.status.UPLOAD_RETRYING,\n                    qq.status.QUEUED\n                ]\n            }).length;\n        },\n\n        getName: function(id) {\n            return this._uploadData.retrieve({id: id}).name;\n        },\n\n        // Parent ID for a specific file, or null if this is the parent, or if it has no parent.\n        getParentId: function(id) {\n            var uploadDataEntry = this.getUploads({id: id}),\n                parentId = null;\n\n            if (uploadDataEntry) {\n                if (uploadDataEntry.parentId !== undefined) {\n                    parentId = uploadDataEntry.parentId;\n                }\n            }\n\n            return parentId;\n        },\n\n        getResumableFilesData: function() {\n            return this._handler.getResumableFilesData();\n        },\n\n        getSize: function(id) {\n            return this._uploadData.retrieve({id: id}).size;\n        },\n\n        getNetUploads: function() {\n            return this._netUploaded;\n        },\n\n        getRemainingAllowedItems: function() {\n            var allowedItems = this._currentItemLimit;\n\n            if (allowedItems > 0) {\n                return allowedItems - this._netUploadedOrQueued;\n            }\n\n            return null;\n        },\n\n        getUploads: function(optionalFilter) {\n            return this._uploadData.retrieve(optionalFilter);\n        },\n\n        getUuid: function(id) {\n            return this._uploadData.retrieve({id: id}).uuid;\n        },\n\n        isResumable: function(id) {\n            return this._handler.hasResumeRecord(id);\n        },\n\n        log: function(str, level) {\n            if (this._options.debug && (!level || level === \"info\")) {\n                qq.log(\"[Fine Uploader \" + qq.version + \"] \" + str);\n            }\n            else if (level && level !== \"info\") {\n                qq.log(\"[Fine Uploader \" + qq.version + \"] \" + str, level);\n\n            }\n        },\n\n        pauseUpload: function(id) {\n            var uploadData = this._uploadData.retrieve({id: id});\n\n            if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {\n                return false;\n            }\n\n            // Pause only really makes sense if the file is uploading or retrying\n            if (qq.indexOf([qq.status.UPLOADING, qq.status.UPLOAD_RETRYING], uploadData.status) >= 0) {\n                if (this._handler.pause(id)) {\n                    this._uploadData.setStatus(id, qq.status.PAUSED);\n                    return true;\n                }\n                else {\n                    this.log(qq.format(\"Unable to pause file ID {} ({}).\", id, this.getName(id)), \"error\");\n                }\n            }\n            else {\n                this.log(qq.format(\"Ignoring pause for file ID {} ({}).  Not in progress.\", id, this.getName(id)), \"error\");\n            }\n\n            return false;\n        },\n\n        removeFileRef: function(id) {\n            this._handler.expunge(id);\n            this._uploadData.removeFileRef(id);\n        },\n\n        reset: function() {\n            this.log(\"Resetting uploader...\");\n\n            this._handler.reset();\n            this._storedIds = [];\n            this._autoRetries = [];\n            this._retryTimeouts = [];\n            this._preventRetries = [];\n            this._thumbnailUrls = [];\n\n            qq.each(this._buttons, function(idx, button) {\n                button.reset();\n            });\n\n            this._paramsStore.reset();\n            this._endpointStore.reset();\n            this._netUploadedOrQueued = 0;\n            this._netUploaded = 0;\n            this._uploadData.reset();\n            this._buttonIdsForFileIds = [];\n\n            this._pasteHandler && this._pasteHandler.reset();\n            this._options.session.refreshOnReset && this._refreshSessionData();\n\n            this._succeededSinceLastAllComplete = [];\n            this._failedSinceLastAllComplete = [];\n\n            this._totalProgress && this._totalProgress.reset();\n\n            this._customResumeDataStore.reset();\n        },\n\n        retry: function(id) {\n            return this._manualRetry(id);\n        },\n\n        scaleImage: function(id, specs) {\n            var self = this;\n\n            return qq.Scaler.prototype.scaleImage(id, specs, {\n                log: qq.bind(self.log, self),\n                getFile: qq.bind(self.getFile, self),\n                uploadData: self._uploadData\n            });\n        },\n\n        setCustomHeaders: function(headers, id) {\n            this._customHeadersStore.set(headers, id);\n        },\n\n        setCustomResumeData: function(id, data) {\n            this._customResumeDataStore.set(data, id);\n        },\n\n        setDeleteFileCustomHeaders: function(headers, id) {\n            this._deleteFileCustomHeadersStore.set(headers, id);\n        },\n\n        setDeleteFileEndpoint: function(endpoint, id) {\n            this._deleteFileEndpointStore.set(endpoint, id);\n        },\n\n        setDeleteFileParams: function(params, id) {\n            this._deleteFileParamsStore.set(params, id);\n        },\n\n        // Re-sets the default endpoint, an endpoint for a specific file, or an endpoint for a specific button\n        setEndpoint: function(endpoint, id) {\n            this._endpointStore.set(endpoint, id);\n        },\n\n        setForm: function(elementOrId) {\n            this._updateFormSupportAndParams(elementOrId);\n        },\n\n        setItemLimit: function(newItemLimit) {\n            this._currentItemLimit = newItemLimit;\n        },\n\n        setName: function(id, newName) {\n            this._uploadData.updateName(id, newName);\n        },\n\n        setParams: function(params, id) {\n            this._paramsStore.set(params, id);\n        },\n\n        setUuid: function(id, newUuid) {\n            return this._uploadData.uuidChanged(id, newUuid);\n        },\n\n        /**\n         * Expose the internal status of a file id to the public api for manual state changes\n         * @public\n         *\n         * @param {Number} id,\n         * @param {String} newStatus\n         *\n         * @todo Implement the remaining methods\n         */\n        setStatus: function(id, newStatus) {\n            var fileRecord = this.getUploads({id: id});\n            if (!fileRecord) {\n                throw new qq.Error(id + \" is not a valid file ID.\");\n            }\n\n            switch (newStatus) {\n                case qq.status.DELETED:\n                    this._onDeleteComplete(id, null, false);\n                    break;\n                case qq.status.DELETE_FAILED:\n                    this._onDeleteComplete(id, null, true);\n                    break;\n                default:\n                    var errorMessage = \"Method setStatus called on '\" + name + \"' not implemented yet for \" + newStatus;\n                    this.log(errorMessage);\n                    throw new qq.Error(errorMessage);\n            }\n        },\n\n        uploadStoredFiles: function() {\n            if (this._storedIds.length === 0) {\n                this._itemError(\"noFilesError\");\n            }\n            else {\n                this._uploadStoredFiles();\n            }\n        }\n    };\n\n    /**\n     * Defines the private (internal) API for FineUploaderBasic mode.\n     */\n    qq.basePrivateApi = {\n        // Updates internal state with a file record (not backed by a live file).  Returns the assigned ID.\n        _addCannedFile: function(sessionData) {\n            var self = this;\n\n            return this._uploadData.addFile({\n                uuid: sessionData.uuid,\n                name: sessionData.name,\n                size: sessionData.size,\n                status: qq.status.UPLOAD_SUCCESSFUL,\n                onBeforeStatusChange: function(id) {\n                    sessionData.deleteFileEndpoint && self.setDeleteFileEndpoint(sessionData.deleteFileEndpoint, id);\n                    sessionData.deleteFileParams && self.setDeleteFileParams(sessionData.deleteFileParams, id);\n\n                    if (sessionData.thumbnailUrl) {\n                        self._thumbnailUrls[id] = sessionData.thumbnailUrl;\n                    }\n\n                    self._netUploaded++;\n                    self._netUploadedOrQueued++;\n                }\n            });\n        },\n\n        _annotateWithButtonId: function(file, associatedInput) {\n            if (qq.isFile(file)) {\n                file.qqButtonId = this._getButtonId(associatedInput);\n            }\n        },\n\n        _batchError: function(message) {\n            this._options.callbacks.onError(null, null, message, undefined);\n        },\n\n        _createDeleteHandler: function() {\n            var self = this;\n\n            return new qq.DeleteFileAjaxRequester({\n                method: this._options.deleteFile.method.toUpperCase(),\n                maxConnections: this._options.maxConnections,\n                uuidParamName: this._options.request.uuidName,\n                customHeaders: this._deleteFileCustomHeadersStore,\n                paramsStore: this._deleteFileParamsStore,\n                endpointStore: this._deleteFileEndpointStore,\n                cors: this._options.cors,\n                log: qq.bind(self.log, self),\n                onDelete: function(id) {\n                    self._onDelete(id);\n                    self._options.callbacks.onDelete(id);\n                },\n                onDeleteComplete: function(id, xhrOrXdr, isError) {\n                    self._onDeleteComplete(id, xhrOrXdr, isError);\n                    self._options.callbacks.onDeleteComplete(id, xhrOrXdr, isError);\n                }\n\n            });\n        },\n\n        _createPasteHandler: function() {\n            var self = this;\n\n            return new qq.PasteSupport({\n                targetElement: this._options.paste.targetElement,\n                callbacks: {\n                    log: qq.bind(self.log, self),\n                    pasteReceived: function(blob) {\n                        self._handleCheckedCallback({\n                            name: \"onPasteReceived\",\n                            callback: qq.bind(self._options.callbacks.onPasteReceived, self, blob),\n                            onSuccess: qq.bind(self._handlePasteSuccess, self, blob),\n                            identifier: \"pasted image\"\n                        });\n                    }\n                }\n            });\n        },\n\n        _createStore: function(initialValue, _readOnlyValues_) {\n            var store = {},\n                catchall = initialValue,\n                perIdReadOnlyValues = {},\n                readOnlyValues = _readOnlyValues_,\n                copy = function(orig) {\n                    if (qq.isObject(orig)) {\n                        return qq.extend({}, orig);\n                    }\n                    return orig;\n                },\n                getReadOnlyValues = function() {\n                    if (qq.isFunction(readOnlyValues)) {\n                        return readOnlyValues();\n                    }\n                    return readOnlyValues;\n                },\n                includeReadOnlyValues = function(id, existing) {\n                    if (readOnlyValues && qq.isObject(existing)) {\n                        qq.extend(existing, getReadOnlyValues());\n                    }\n\n                    if (perIdReadOnlyValues[id]) {\n                        qq.extend(existing, perIdReadOnlyValues[id]);\n                    }\n                };\n\n            return {\n                set: function(val, id) {\n                    /*jshint eqeqeq: true, eqnull: true*/\n                    if (id == null) {\n                        store = {};\n                        catchall = copy(val);\n                    }\n                    else {\n                        store[id] = copy(val);\n                    }\n                },\n\n                get: function(id) {\n                    var values;\n\n                    /*jshint eqeqeq: true, eqnull: true*/\n                    if (id != null && store[id]) {\n                        values = store[id];\n                    }\n                    else {\n                        values = copy(catchall);\n                    }\n\n                    includeReadOnlyValues(id, values);\n\n                    return copy(values);\n                },\n\n                addReadOnly: function(id, values) {\n                    // Only applicable to Object stores\n                    if (qq.isObject(store)) {\n                        // If null ID, apply readonly values to all files\n                        if (id === null) {\n                            if (qq.isFunction(values)) {\n                                readOnlyValues = values;\n                            }\n                            else {\n                                readOnlyValues = readOnlyValues || {};\n                                qq.extend(readOnlyValues, values);\n                            }\n                        }\n                        else {\n                            perIdReadOnlyValues[id] = perIdReadOnlyValues[id] || {};\n                            qq.extend(perIdReadOnlyValues[id], values);\n                        }\n                    }\n                },\n\n                remove: function(fileId) {\n                    return delete store[fileId];\n                },\n\n                reset: function() {\n                    store = {};\n                    perIdReadOnlyValues = {};\n                    catchall = initialValue;\n                }\n            };\n        },\n\n        _createUploadDataTracker: function() {\n            var self = this;\n\n            return new qq.UploadData({\n                getName: function(id) {\n                    return self.getName(id);\n                },\n                getUuid: function(id) {\n                    return self.getUuid(id);\n                },\n                getSize: function(id) {\n                    return self.getSize(id);\n                },\n                onStatusChange: function(id, oldStatus, newStatus) {\n                    self._onUploadStatusChange(id, oldStatus, newStatus);\n                    self._options.callbacks.onStatusChange(id, oldStatus, newStatus);\n                    self._maybeAllComplete(id, newStatus);\n\n                    if (self._totalProgress) {\n                        setTimeout(function() {\n                            self._totalProgress.onStatusChange(id, oldStatus, newStatus);\n                        }, 0);\n                    }\n                }\n            });\n        },\n\n        /**\n         * Generate a tracked upload button.\n         *\n         * @param spec Object containing a required `element` property\n         * along with optional `multiple`, `accept`, and `folders`.\n         * @returns {qq.UploadButton}\n         * @private\n         */\n        _createUploadButton: function(spec) {\n            var self = this,\n                acceptFiles = spec.accept || this._options.validation.acceptFiles,\n                allowedExtensions = spec.allowedExtensions || this._options.validation.allowedExtensions,\n                button;\n\n            function allowMultiple() {\n                if (qq.supportedFeatures.ajaxUploading) {\n                    // Workaround for bug in iOS7+ (see #1039)\n                    if (self._options.workarounds.iosEmptyVideos &&\n                        qq.ios() &&\n                        !qq.ios6() &&\n                        self._isAllowedExtension(allowedExtensions, \".mov\")) {\n\n                        return false;\n                    }\n\n                    if (spec.multiple === undefined) {\n                        return self._options.multiple;\n                    }\n\n                    return spec.multiple;\n                }\n\n                return false;\n            }\n\n            button = new qq.UploadButton({\n                acceptFiles: acceptFiles,\n                element: spec.element,\n                focusClass: this._options.classes.buttonFocus,\n                folders: spec.folders,\n                hoverClass: this._options.classes.buttonHover,\n                ios8BrowserCrashWorkaround: this._options.workarounds.ios8BrowserCrash,\n                multiple: allowMultiple(),\n                name: this._options.request.inputName,\n                onChange: function(input) {\n                    self._onInputChange(input);\n                },\n                title: spec.title == null ? this._options.text.fileInputTitle : spec.title\n            });\n\n            this._disposeSupport.addDisposer(function() {\n                button.dispose();\n            });\n\n            self._buttons.push(button);\n\n            return button;\n        },\n\n        _createUploadHandler: function(additionalOptions, namespace) {\n            var self = this,\n                lastOnProgress = {},\n                options = {\n                    debug: this._options.debug,\n                    maxConnections: this._options.maxConnections,\n                    cors: this._options.cors,\n                    paramsStore: this._paramsStore,\n                    endpointStore: this._endpointStore,\n                    chunking: this._options.chunking,\n                    resume: this._options.resume,\n                    blobs: this._options.blobs,\n                    log: qq.bind(self.log, self),\n                    preventRetryParam: this._options.retry.preventRetryResponseProperty,\n                    onProgress: function(id, name, loaded, total) {\n                        if (loaded < 0 || total < 0) {\n                            return;\n                        }\n\n                        if (lastOnProgress[id]) {\n                            if (lastOnProgress[id].loaded !== loaded || lastOnProgress[id].total !== total) {\n                                self._onProgress(id, name, loaded, total);\n                                self._options.callbacks.onProgress(id, name, loaded, total);\n                            }\n                        }\n                        else {\n                            self._onProgress(id, name, loaded, total);\n                            self._options.callbacks.onProgress(id, name, loaded, total);\n                        }\n\n                        lastOnProgress[id] = {loaded: loaded, total: total};\n\n                    },\n                    onComplete: function(id, name, result, xhr) {\n                        delete lastOnProgress[id];\n\n                        var status = self.getUploads({id: id}).status,\n                            retVal;\n\n                        // This is to deal with some observed cases where the XHR readyStateChange handler is\n                        // invoked by the browser multiple times for the same XHR instance with the same state\n                        // readyState value.  Higher level: don't invoke complete-related code if we've already\n                        // done this.\n                        if (status === qq.status.UPLOAD_SUCCESSFUL || status === qq.status.UPLOAD_FAILED) {\n                            return;\n                        }\n\n                        retVal = self._onComplete(id, name, result, xhr);\n\n                        // If the internal `_onComplete` handler returns a promise, don't invoke the `onComplete` callback\n                        // until the promise has been fulfilled.\n                        if (retVal instanceof  qq.Promise) {\n                            retVal.done(function() {\n                                self._options.callbacks.onComplete(id, name, result, xhr);\n                            });\n                        }\n                        else {\n                            self._options.callbacks.onComplete(id, name, result, xhr);\n                        }\n                    },\n                    onCancel: function(id, name, cancelFinalizationEffort) {\n                        var promise = new qq.Promise();\n\n                        self._handleCheckedCallback({\n                            name: \"onCancel\",\n                            callback: qq.bind(self._options.callbacks.onCancel, self, id, name),\n                            onFailure: promise.failure,\n                            onSuccess: function() {\n                                cancelFinalizationEffort.then(function() {\n                                    self._onCancel(id, name);\n                                });\n\n                                promise.success();\n                            },\n                            identifier: id\n                        });\n\n                        return promise;\n                    },\n                    onUploadPrep: qq.bind(this._onUploadPrep, this),\n                    onUpload: function(id, name) {\n                        self._onUpload(id, name);\n                        var onUploadResult = self._options.callbacks.onUpload(id, name);\n\n                        if (qq.isGenericPromise(onUploadResult)) {\n                            self.log(qq.format(\"onUpload for {} returned a Promise - waiting for resolution.\", id));\n                            return onUploadResult;\n                        }\n\n                        return new qq.Promise().success();\n                    },\n                    onUploadChunk: function(id, name, chunkData) {\n                        self._onUploadChunk(id, chunkData);\n                        var onUploadChunkResult = self._options.callbacks.onUploadChunk(id, name, chunkData);\n\n                        if (qq.isGenericPromise(onUploadChunkResult)) {\n                            self.log(qq.format(\"onUploadChunk for {}.{} returned a Promise - waiting for resolution.\", id, chunkData.partIndex));\n                            return onUploadChunkResult;\n                        }\n\n                        return new qq.Promise().success();\n                    },\n                    onUploadChunkSuccess: function(id, chunkData, result, xhr) {\n                        self._onUploadChunkSuccess(id, chunkData);\n                        self._options.callbacks.onUploadChunkSuccess.apply(self, arguments);\n                    },\n                    onResume: function(id, name, chunkData, customResumeData) {\n                        return self._options.callbacks.onResume(id, name, chunkData, customResumeData);\n                    },\n                    onAutoRetry: function(id, name, responseJSON, xhr) {\n                        return self._onAutoRetry.apply(self, arguments);\n                    },\n                    onUuidChanged: function(id, newUuid) {\n                        self.log(\"Server requested UUID change from '\" + self.getUuid(id) + \"' to '\" + newUuid + \"'\");\n                        self.setUuid(id, newUuid);\n                    },\n                    getName: qq.bind(self.getName, self),\n                    getUuid: qq.bind(self.getUuid, self),\n                    getSize: qq.bind(self.getSize, self),\n                    setSize: qq.bind(self._setSize, self),\n                    getDataByUuid: function(uuid) {\n                        return self.getUploads({uuid: uuid});\n                    },\n                    isQueued: function(id) {\n                        var status = self.getUploads({id: id}).status;\n                        return status === qq.status.QUEUED ||\n                            status === qq.status.SUBMITTED ||\n                            status === qq.status.UPLOAD_RETRYING ||\n                            status === qq.status.PAUSED;\n                    },\n                    getIdsInProxyGroup: self._uploadData.getIdsInProxyGroup,\n                    getIdsInBatch: self._uploadData.getIdsInBatch,\n                    isInProgress: function(id) {\n                        return self.getUploads({id: id}).status === qq.status.UPLOADING;\n                    },\n                    getCustomResumeData: qq.bind(self._getCustomResumeData, self),\n                    setStatus: function(id, status) {\n                        self._uploadData.setStatus(id, status);\n                    }\n                };\n\n            qq.each(this._options.request, function(prop, val) {\n                options[prop] = val;\n            });\n\n            options.customHeaders = this._customHeadersStore;\n\n            if (additionalOptions) {\n                qq.each(additionalOptions, function(key, val) {\n                    options[key] = val;\n                });\n            }\n\n            return new qq.UploadHandlerController(options, namespace);\n        },\n\n        _fileOrBlobRejected: function(id) {\n            this._netUploadedOrQueued--;\n            this._uploadData.setStatus(id, qq.status.REJECTED);\n        },\n\n        _formatSize: function(bytes) {\n            if (bytes === 0) {\n                return bytes + this._options.text.sizeSymbols[0];\n            }\n            var i = -1;\n            do {\n                bytes = bytes / 1000;\n                i++;\n            } while (bytes > 999);\n\n            return Math.max(bytes, 0.1).toFixed(1) + this._options.text.sizeSymbols[i];\n        },\n\n        // Creates an internal object that tracks various properties of each extra button,\n        // and then actually creates the extra button.\n        _generateExtraButtonSpecs: function() {\n            var self = this;\n\n            this._extraButtonSpecs = {};\n\n            qq.each(this._options.extraButtons, function(idx, extraButtonOptionEntry) {\n                var multiple = extraButtonOptionEntry.multiple,\n                    validation = qq.extend({}, self._options.validation, true),\n                    extraButtonSpec = qq.extend({}, extraButtonOptionEntry);\n\n                if (multiple === undefined) {\n                    multiple = self._options.multiple;\n                }\n\n                if (extraButtonSpec.validation) {\n                    qq.extend(validation, extraButtonOptionEntry.validation, true);\n                }\n\n                qq.extend(extraButtonSpec, {\n                    multiple: multiple,\n                    validation: validation\n                }, true);\n\n                self._initExtraButton(extraButtonSpec);\n            });\n        },\n\n        _getButton: function(buttonId) {\n            var extraButtonsSpec = this._extraButtonSpecs[buttonId];\n\n            if (extraButtonsSpec) {\n                return extraButtonsSpec.element;\n            }\n            else if (buttonId === this._defaultButtonId) {\n                return this._options.button;\n            }\n        },\n\n        /**\n         * Gets the internally used tracking ID for a button.\n         *\n         * @param buttonOrFileInputOrFile `File`, `<input type=\"file\">`, or a button container element\n         * @returns {*} The button's ID, or undefined if no ID is recoverable\n         * @private\n         */\n        _getButtonId: function(buttonOrFileInputOrFile) {\n            var inputs, fileInput,\n                fileBlobOrInput = buttonOrFileInputOrFile;\n\n            // We want the reference file/blob here if this is a proxy (a file that will be generated on-demand later)\n            if (fileBlobOrInput instanceof qq.BlobProxy) {\n                fileBlobOrInput = fileBlobOrInput.referenceBlob;\n            }\n\n            // If the item is a `Blob` it will never be associated with a button or drop zone.\n            if (fileBlobOrInput && !qq.isBlob(fileBlobOrInput)) {\n                if (qq.isFile(fileBlobOrInput)) {\n                    return fileBlobOrInput.qqButtonId;\n                }\n                else if (fileBlobOrInput.tagName.toLowerCase() === \"input\" &&\n                    fileBlobOrInput.type.toLowerCase() === \"file\") {\n\n                    return fileBlobOrInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);\n                }\n\n                inputs = fileBlobOrInput.getElementsByTagName(\"input\");\n\n                qq.each(inputs, function(idx, input) {\n                    if (input.getAttribute(\"type\") === \"file\") {\n                        fileInput = input;\n                        return false;\n                    }\n                });\n\n                if (fileInput) {\n                    return fileInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);\n                }\n            }\n        },\n\n        _getCustomResumeData: function(fileId) {\n            return this._customResumeDataStore.get(fileId);\n        },\n\n        _getNotFinished: function() {\n            return this._uploadData.retrieve({\n                status: [\n                    qq.status.UPLOADING,\n                    qq.status.UPLOAD_RETRYING,\n                    qq.status.QUEUED,\n                    qq.status.SUBMITTING,\n                    qq.status.SUBMITTED,\n                    qq.status.PAUSED\n                ]\n            }).length;\n        },\n\n        // Get the validation options for this button.  Could be the default validation option\n        // or a specific one assigned to this particular button.\n        _getValidationBase: function(buttonId) {\n            var extraButtonSpec = this._extraButtonSpecs[buttonId];\n\n            return extraButtonSpec ? extraButtonSpec.validation : this._options.validation;\n        },\n\n        _getValidationDescriptor: function(fileWrapper) {\n            if (fileWrapper.file instanceof qq.BlobProxy) {\n                return {\n                    name: qq.getFilename(fileWrapper.file.referenceBlob),\n                    size: fileWrapper.file.referenceBlob.size\n                };\n            }\n\n            return {\n                name: this.getUploads({id: fileWrapper.id}).name,\n                size: this.getUploads({id: fileWrapper.id}).size\n            };\n        },\n\n        _getValidationDescriptors: function(fileWrappers) {\n            var self = this,\n                fileDescriptors = [];\n\n            qq.each(fileWrappers, function(idx, fileWrapper) {\n                fileDescriptors.push(self._getValidationDescriptor(fileWrapper));\n            });\n\n            return fileDescriptors;\n        },\n\n        // Allows camera access on either the default or an extra button for iOS devices.\n        _handleCameraAccess: function() {\n            if (this._options.camera.ios && qq.ios()) {\n                var acceptIosCamera = \"image/*;capture=camera\",\n                    button = this._options.camera.button,\n                    buttonId = button ? this._getButtonId(button) : this._defaultButtonId,\n                    optionRoot = this._options;\n\n                // If we are not targeting the default button, it is an \"extra\" button\n                if (buttonId && buttonId !== this._defaultButtonId) {\n                    optionRoot = this._extraButtonSpecs[buttonId];\n                }\n\n                // Camera access won't work in iOS if the `multiple` attribute is present on the file input\n                optionRoot.multiple = false;\n\n                // update the options\n                if (optionRoot.validation.acceptFiles === null) {\n                    optionRoot.validation.acceptFiles = acceptIosCamera;\n                }\n                else {\n                    optionRoot.validation.acceptFiles += \",\" + acceptIosCamera;\n                }\n\n                // update the already-created button\n                qq.each(this._buttons, function(idx, button) {\n                    if (button.getButtonId() === buttonId) {\n                        button.setMultiple(optionRoot.multiple);\n                        button.setAcceptFiles(optionRoot.acceptFiles);\n\n                        return false;\n                    }\n                });\n            }\n        },\n\n        _handleCheckedCallback: function(details) {\n            var self = this,\n                callbackRetVal = details.callback();\n\n            if (qq.isGenericPromise(callbackRetVal)) {\n                this.log(details.name + \" - waiting for \" + details.name + \" promise to be fulfilled for \" + details.identifier);\n                return callbackRetVal.then(\n                    function(successParam) {\n                        self.log(details.name + \" promise success for \" + details.identifier);\n                        details.onSuccess(successParam);\n                    },\n                    function() {\n                        if (details.onFailure) {\n                            self.log(details.name + \" promise failure for \" + details.identifier);\n                            details.onFailure();\n                        }\n                        else {\n                            self.log(details.name + \" promise failure for \" + details.identifier);\n                        }\n                    });\n            }\n\n            if (callbackRetVal !== false) {\n                details.onSuccess(callbackRetVal);\n            }\n            else {\n                if (details.onFailure) {\n                    this.log(details.name + \" - return value was 'false' for \" + details.identifier + \".  Invoking failure callback.\");\n                    details.onFailure();\n                }\n                else {\n                    this.log(details.name + \" - return value was 'false' for \" + details.identifier + \".  Will not proceed.\");\n                }\n            }\n\n            return callbackRetVal;\n        },\n\n        // Updates internal state when a new file has been received, and adds it along with its ID to a passed array.\n        _handleNewFile: function(file, batchId, newFileWrapperList) {\n            var self = this,\n                uuid = qq.getUniqueId(),\n                size = -1,\n                name = qq.getFilename(file),\n                actualFile = file.blob || file,\n                handler = this._customNewFileHandler ?\n                    this._customNewFileHandler :\n                    qq.bind(self._handleNewFileGeneric, self);\n\n            if (!qq.isInput(actualFile) && actualFile.size >= 0) {\n                size = actualFile.size;\n            }\n\n            handler(actualFile, name, uuid, size, newFileWrapperList, batchId, this._options.request.uuidName, {\n                uploadData: self._uploadData,\n                paramsStore: self._paramsStore,\n                addFileToHandler: function(id, file) {\n                    self._handler.add(id, file);\n                    self._netUploadedOrQueued++;\n                    self._trackButton(id);\n                }\n            });\n        },\n\n        _handleNewFileGeneric: function(file, name, uuid, size, fileList, batchId) {\n            var id = this._uploadData.addFile({\n                uuid: uuid,\n                name: name,\n                size: size,\n                batchId: batchId,\n                file: file\n            });\n\n            this._handler.add(id, file);\n\n            this._trackButton(id);\n\n            this._netUploadedOrQueued++;\n\n            fileList.push({id: id, file: file});\n        },\n\n        _handlePasteSuccess: function(blob, extSuppliedName) {\n            var extension = blob.type.split(\"/\")[1],\n                name = extSuppliedName;\n\n            /*jshint eqeqeq: true, eqnull: true*/\n            if (name == null) {\n                name = this._options.paste.defaultName;\n            }\n\n            name += \".\" + extension;\n\n            this.addFiles({\n                name: name,\n                blob: blob\n            });\n        },\n\n        _handleDeleteSuccess: function(id) {\n            if (this.getUploads({id: id}).status !== qq.status.DELETED) {\n                var name = this.getName(id);\n\n                this._netUploadedOrQueued--;\n                this._netUploaded--;\n                this._handler.expunge(id);\n                this._uploadData.setStatus(id, qq.status.DELETED);\n                this.log(\"Delete request for '\" + name + \"' has succeeded.\");\n            }\n        },\n\n        _handleDeleteFailed: function(id, xhrOrXdr) {\n            var name = this.getName(id);\n\n            this._uploadData.setStatus(id, qq.status.DELETE_FAILED);\n            this.log(\"Delete request for '\" + name + \"' has failed.\", \"error\");\n\n            // Check first if xhrOrXdr is actually passed or valid\n            // For error reporting, we only have access to the response status if this is not\n            // an `XDomainRequest`.\n            if (!xhrOrXdr || xhrOrXdr.withCredentials === undefined) {\n                this._options.callbacks.onError(id, name, \"Delete request failed\", xhrOrXdr);\n            }\n            else {\n                this._options.callbacks.onError(id, name, \"Delete request failed with response code \" + xhrOrXdr.status, xhrOrXdr);\n            }\n        },\n\n        // Creates an extra button element\n        _initExtraButton: function(spec) {\n            var button = this._createUploadButton({\n                accept: spec.validation.acceptFiles,\n                allowedExtensions: spec.validation.allowedExtensions,\n                element: spec.element,\n                folders: spec.folders,\n                multiple: spec.multiple,\n                title: spec.fileInputTitle\n            });\n\n            this._extraButtonSpecs[button.getButtonId()] = spec;\n        },\n\n        _initFormSupportAndParams: function() {\n            this._formSupport = qq.FormSupport && new qq.FormSupport(\n                this._options.form, qq.bind(this.uploadStoredFiles, this), qq.bind(this.log, this)\n            );\n\n            if (this._formSupport && this._formSupport.attachedToForm) {\n                this._paramsStore = this._createStore(\n                    this._options.request.params,  this._formSupport.getFormInputsAsObject\n                );\n\n                this._options.autoUpload = this._formSupport.newAutoUpload;\n                if (this._formSupport.newEndpoint) {\n                    this._options.request.endpoint = this._formSupport.newEndpoint;\n                }\n            }\n            else {\n                this._paramsStore = this._createStore(this._options.request.params);\n            }\n        },\n\n        _isDeletePossible: function() {\n            if (!qq.DeleteFileAjaxRequester || !this._options.deleteFile.enabled) {\n                return false;\n            }\n\n            if (this._options.cors.expected) {\n                if (qq.supportedFeatures.deleteFileCorsXhr) {\n                    return true;\n                }\n\n                if (qq.supportedFeatures.deleteFileCorsXdr && this._options.cors.allowXdr) {\n                    return true;\n                }\n\n                return false;\n            }\n\n            return true;\n        },\n\n        _isAllowedExtension: function(allowed, fileName) {\n            var valid = false;\n\n            if (!allowed.length) {\n                return true;\n            }\n\n            qq.each(allowed, function(idx, allowedExt) {\n                /**\n                 * If an argument is not a string, ignore it.  Added when a possible issue with MooTools hijacking the\n                 * `allowedExtensions` array was discovered.  See case #735 in the issue tracker for more details.\n                 */\n                if (qq.isString(allowedExt)) {\n                    /*jshint eqeqeq: true, eqnull: true*/\n                    var extRegex = new RegExp(\"\\\\.\" + allowedExt + \"$\", \"i\");\n\n                    if (fileName.match(extRegex) != null) {\n                        valid = true;\n                        return false;\n                    }\n                }\n            });\n\n            return valid;\n        },\n\n        /**\n         * Constructs and returns a message that describes an item/file error.  Also calls `onError` callback.\n         *\n         * @param code REQUIRED - a code that corresponds to a stock message describing this type of error\n         * @param maybeNameOrNames names of the items that have failed, if applicable\n         * @param item `File`, `Blob`, or `<input type=\"file\">`\n         * @private\n         */\n        _itemError: function(code, maybeNameOrNames, item) {\n            var message = this._options.messages[code],\n                allowedExtensions = [],\n                names = [].concat(maybeNameOrNames),\n                name = names[0],\n                buttonId = this._getButtonId(item),\n                validationBase = this._getValidationBase(buttonId),\n                extensionsForMessage, placeholderMatch;\n\n            function r(name, replacement) { message = message.replace(name, replacement); }\n\n            qq.each(validationBase.allowedExtensions, function(idx, allowedExtension) {\n                /**\n                 * If an argument is not a string, ignore it.  Added when a possible issue with MooTools hijacking the\n                 * `allowedExtensions` array was discovered.  See case #735 in the issue tracker for more details.\n                 */\n                if (qq.isString(allowedExtension)) {\n                    allowedExtensions.push(allowedExtension);\n                }\n            });\n\n            extensionsForMessage = allowedExtensions.join(\", \").toLowerCase();\n\n            r(\"{file}\", this._options.formatFileName(name));\n            r(\"{extensions}\", extensionsForMessage);\n            r(\"{sizeLimit}\", this._formatSize(validationBase.sizeLimit));\n            r(\"{minSizeLimit}\", this._formatSize(validationBase.minSizeLimit));\n\n            placeholderMatch = message.match(/(\\{\\w+\\})/g);\n            if (placeholderMatch !== null) {\n                qq.each(placeholderMatch, function(idx, placeholder) {\n                    r(placeholder, names[idx]);\n                });\n            }\n\n            this._options.callbacks.onError(null, name, message, undefined);\n\n            return message;\n        },\n\n        /**\n         * Conditionally orders a manual retry of a failed upload.\n         *\n         * @param id File ID of the failed upload\n         * @param callback Optional callback to invoke if a retry is prudent.\n         * In lieu of asking the upload handler to retry.\n         * @returns {boolean} true if a manual retry will occur\n         * @private\n         */\n        _manualRetry: function(id, callback) {\n            if (this._onBeforeManualRetry(id)) {\n                this._netUploadedOrQueued++;\n                this._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);\n\n                if (callback) {\n                    callback(id);\n                }\n                else {\n                    this._handler.retry(id);\n                }\n\n                return true;\n            }\n        },\n\n        _maybeAllComplete: function(id, status) {\n            var self = this,\n                notFinished = this._getNotFinished();\n\n            if (status === qq.status.UPLOAD_SUCCESSFUL) {\n                this._succeededSinceLastAllComplete.push(id);\n            }\n            else if (status === qq.status.UPLOAD_FAILED) {\n                this._failedSinceLastAllComplete.push(id);\n            }\n\n            if (notFinished === 0 &&\n                (this._succeededSinceLastAllComplete.length || this._failedSinceLastAllComplete.length)) {\n                // Attempt to ensure onAllComplete is not invoked before other callbacks, such as onCancel & onComplete\n                setTimeout(function() {\n                    self._onAllComplete(self._succeededSinceLastAllComplete, self._failedSinceLastAllComplete);\n                }, 0);\n            }\n        },\n\n        _maybeHandleIos8SafariWorkaround: function() {\n            var self = this;\n\n            if (this._options.workarounds.ios8SafariUploads && qq.ios800() && qq.iosSafari()) {\n                setTimeout(function() {\n                    window.alert(self._options.messages.unsupportedBrowserIos8Safari);\n                }, 0);\n                throw new qq.Error(this._options.messages.unsupportedBrowserIos8Safari);\n            }\n        },\n\n        _maybeParseAndSendUploadError: function(id, name, response, xhr) {\n            // Assuming no one will actually set the response code to something other than 200\n            // and still set 'success' to true...\n            if (!response.success) {\n                if (xhr && xhr.status !== 200 && !response.error) {\n                    this._options.callbacks.onError(id, name, \"XHR returned response code \" + xhr.status, xhr);\n                }\n                else {\n                    var errorReason = response.error ? response.error : this._options.text.defaultResponseError;\n                    this._options.callbacks.onError(id, name, errorReason, xhr);\n                }\n            }\n        },\n\n        _maybeProcessNextItemAfterOnValidateCallback: function(validItem, items, index, params, endpoint) {\n            var self = this;\n\n            if (items.length > index) {\n                if (validItem || !this._options.validation.stopOnFirstInvalidFile) {\n                    //use setTimeout to prevent a stack overflow with a large number of files in the batch & non-promissory callbacks\n                    setTimeout(function() {\n                        var validationDescriptor = self._getValidationDescriptor(items[index]),\n                            buttonId = self._getButtonId(items[index].file),\n                            button = self._getButton(buttonId);\n\n                        self._handleCheckedCallback({\n                            name: \"onValidate\",\n                            callback: qq.bind(self._options.callbacks.onValidate, self, validationDescriptor, button),\n                            onSuccess: qq.bind(self._onValidateCallbackSuccess, self, items, index, params, endpoint),\n                            onFailure: qq.bind(self._onValidateCallbackFailure, self, items, index, params, endpoint),\n                            identifier: \"Item '\" + validationDescriptor.name + \"', size: \" + validationDescriptor.size\n                        });\n                    }, 0);\n                }\n                else if (!validItem) {\n                    for (; index < items.length; index++) {\n                        self._fileOrBlobRejected(items[index].id);\n                    }\n                }\n            }\n        },\n\n        _onAllComplete: function(successful, failed) {\n            this._totalProgress && this._totalProgress.onAllComplete(successful, failed, this._preventRetries);\n\n            this._options.callbacks.onAllComplete(qq.extend([], successful), qq.extend([], failed));\n\n            this._succeededSinceLastAllComplete = [];\n            this._failedSinceLastAllComplete = [];\n        },\n\n        /**\n         * Attempt to automatically retry a failed upload.\n         *\n         * @param id The file ID of the failed upload\n         * @param name The name of the file associated with the failed upload\n         * @param responseJSON Response from the server, parsed into a javascript object\n         * @param xhr Ajax transport used to send the failed request\n         * @param callback Optional callback to be invoked if a retry is prudent.\n         * Invoked in lieu of asking the upload handler to retry.\n         * @returns {boolean} true if an auto-retry will occur\n         * @private\n         */\n        _onAutoRetry: function(id, name, responseJSON, xhr, callback) {\n            var self = this;\n\n            self._preventRetries[id] = responseJSON[self._options.retry.preventRetryResponseProperty];\n\n            if (self._shouldAutoRetry(id)) {\n                var retryWaitPeriod = self._options.retry.autoAttemptDelay * 1000;\n\n                self._maybeParseAndSendUploadError.apply(self, arguments);\n                self._options.callbacks.onAutoRetry(id, name, self._autoRetries[id]);\n                self._onBeforeAutoRetry(id, name);\n\n                self._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);\n                self._retryTimeouts[id] = setTimeout(function() {\n                    self.log(\"Starting retry for \" + name + \"...\");\n\n                    if (callback) {\n                        callback(id);\n                    }\n                    else {\n                        self._handler.retry(id);\n                    }\n                }, retryWaitPeriod);\n\n                return true;\n            }\n        },\n\n        _onBeforeAutoRetry: function(id, name) {\n            this.log(\"Waiting \" + this._options.retry.autoAttemptDelay + \" seconds before retrying \" + name + \"...\");\n        },\n\n        //return false if we should not attempt the requested retry\n        _onBeforeManualRetry: function(id) {\n            var itemLimit = this._currentItemLimit,\n                fileName;\n\n            if (this._preventRetries[id]) {\n                this.log(\"Retries are forbidden for id \" + id, \"warn\");\n                return false;\n            }\n            else if (this._handler.isValid(id)) {\n                fileName = this.getName(id);\n\n                if (this._options.callbacks.onManualRetry(id, fileName) === false) {\n                    return false;\n                }\n\n                if (itemLimit > 0 && this._netUploadedOrQueued + 1 > itemLimit) {\n                    this._itemError(\"retryFailTooManyItems\");\n                    return false;\n                }\n\n                this.log(\"Retrying upload for '\" + fileName + \"' (id: \" + id + \")...\");\n                return true;\n            }\n            else {\n                this.log(\"'\" + id + \"' is not a valid file ID\", \"error\");\n                return false;\n            }\n        },\n\n        _onCancel: function(id, name) {\n            this._netUploadedOrQueued--;\n\n            clearTimeout(this._retryTimeouts[id]);\n\n            var storedItemIndex = qq.indexOf(this._storedIds, id);\n            if (!this._options.autoUpload && storedItemIndex >= 0) {\n                this._storedIds.splice(storedItemIndex, 1);\n            }\n\n            this._uploadData.setStatus(id, qq.status.CANCELED);\n        },\n\n        _onComplete: function(id, name, result, xhr) {\n            if (!result.success) {\n                this._netUploadedOrQueued--;\n                this._uploadData.setStatus(id, qq.status.UPLOAD_FAILED);\n\n                if (result[this._options.retry.preventRetryResponseProperty] === true) {\n                    this._preventRetries[id] = true;\n                }\n            }\n            else {\n                if (result.thumbnailUrl) {\n                    this._thumbnailUrls[id] = result.thumbnailUrl;\n                }\n\n                this._netUploaded++;\n                this._uploadData.setStatus(id, qq.status.UPLOAD_SUCCESSFUL);\n            }\n\n            this._maybeParseAndSendUploadError(id, name, result, xhr);\n\n            return result.success ? true : false;\n        },\n\n        _onDelete: function(id) {\n            this._uploadData.setStatus(id, qq.status.DELETING);\n        },\n\n        _onDeleteComplete: function(id, xhrOrXdr, isError) {\n            var name = this.getName(id);\n\n            if (isError) {\n                this._handleDeleteFailed(id, xhrOrXdr);\n            }\n            else {\n                this._handleDeleteSuccess(id);\n            }\n        },\n\n        _onInputChange: function(input) {\n            var fileIndex;\n\n            if (qq.supportedFeatures.ajaxUploading) {\n                for (fileIndex = 0; fileIndex < input.files.length; fileIndex++) {\n                    this._annotateWithButtonId(input.files[fileIndex], input);\n                }\n\n                this.addFiles(input.files);\n            }\n            // Android 2.3.x will fire `onchange` even if no file has been selected\n            else if (input.value.length > 0) {\n                this.addFiles(input);\n            }\n\n            qq.each(this._buttons, function(idx, button) {\n                button.reset();\n            });\n        },\n\n        _onProgress: function(id, name, loaded, total) {\n            this._totalProgress && this._totalProgress.onIndividualProgress(id, loaded, total);\n        },\n\n        _onSubmit: function(id, name) {\n            //nothing to do yet in core uploader\n        },\n\n        _onSubmitCallbackSuccess: function(id, name) {\n            this._onSubmit.apply(this, arguments);\n            this._uploadData.setStatus(id, qq.status.SUBMITTED);\n            this._onSubmitted.apply(this, arguments);\n\n            if (this._options.autoUpload) {\n                this._options.callbacks.onSubmitted.apply(this, arguments);\n                this._uploadFile(id);\n            }\n            else {\n                this._storeForLater(id);\n                this._options.callbacks.onSubmitted.apply(this, arguments);\n            }\n        },\n\n        _onSubmitDelete: function(id, onSuccessCallback, additionalMandatedParams) {\n            var uuid = this.getUuid(id),\n                adjustedOnSuccessCallback;\n\n            if (onSuccessCallback) {\n                adjustedOnSuccessCallback = qq.bind(onSuccessCallback, this, id, uuid, additionalMandatedParams);\n            }\n\n            if (this._isDeletePossible()) {\n                this._handleCheckedCallback({\n                    name: \"onSubmitDelete\",\n                    callback: qq.bind(this._options.callbacks.onSubmitDelete, this, id),\n                    onSuccess: adjustedOnSuccessCallback ||\n                        qq.bind(this._deleteHandler.sendDelete, this, id, uuid, additionalMandatedParams),\n                    identifier: id\n                });\n                return true;\n            }\n            else {\n                this.log(\"Delete request ignored for ID \" + id + \", delete feature is disabled or request not possible \" +\n                    \"due to CORS on a user agent that does not support pre-flighting.\", \"warn\");\n                return false;\n            }\n        },\n\n        _onSubmitted: function(id) {\n            //nothing to do in the base uploader\n        },\n\n        _onTotalProgress: function(loaded, total) {\n            this._options.callbacks.onTotalProgress(loaded, total);\n        },\n\n        _onUploadPrep: function(id) {\n            // nothing to do in the core uploader for now\n        },\n\n        _onUpload: function(id, name) {\n            this._uploadData.setStatus(id, qq.status.UPLOADING);\n        },\n\n        _onUploadChunk: function(id, chunkData) {\n            //nothing to do in the base uploader\n        },\n\n        _onUploadChunkSuccess: function(id, chunkData) {\n            if (!this._preventRetries[id] && this._options.retry.enableAuto) {\n                this._autoRetries[id] = 0;\n            }\n        },\n\n        _onUploadStatusChange: function(id, oldStatus, newStatus) {\n            // Make sure a \"queued\" retry attempt is canceled if the upload has been paused\n            if (newStatus === qq.status.PAUSED) {\n                clearTimeout(this._retryTimeouts[id]);\n            }\n        },\n\n        _onValidateBatchCallbackFailure: function(fileWrappers) {\n            var self = this;\n\n            qq.each(fileWrappers, function(idx, fileWrapper) {\n                self._fileOrBlobRejected(fileWrapper.id);\n            });\n        },\n\n        _onValidateBatchCallbackSuccess: function(validationDescriptors, items, params, endpoint, button) {\n            var errorMessage,\n                itemLimit = this._currentItemLimit,\n                proposedNetFilesUploadedOrQueued = this._netUploadedOrQueued;\n\n            if (itemLimit === 0 || proposedNetFilesUploadedOrQueued <= itemLimit) {\n                if (items.length > 0) {\n                    this._handleCheckedCallback({\n                        name: \"onValidate\",\n                        callback: qq.bind(this._options.callbacks.onValidate, this, validationDescriptors[0], button),\n                        onSuccess: qq.bind(this._onValidateCallbackSuccess, this, items, 0, params, endpoint),\n                        onFailure: qq.bind(this._onValidateCallbackFailure, this, items, 0, params, endpoint),\n                        identifier: \"Item '\" + items[0].file.name + \"', size: \" + items[0].file.size\n                    });\n                }\n                else {\n                    this._itemError(\"noFilesError\");\n                }\n            }\n            else {\n                this._onValidateBatchCallbackFailure(items);\n                errorMessage = this._options.messages.tooManyItemsError\n                    .replace(/\\{netItems\\}/g, proposedNetFilesUploadedOrQueued)\n                    .replace(/\\{itemLimit\\}/g, itemLimit);\n                this._batchError(errorMessage);\n            }\n        },\n\n        _onValidateCallbackFailure: function(items, index, params, endpoint) {\n            var nextIndex = index + 1;\n\n            this._fileOrBlobRejected(items[index].id, items[index].file.name);\n\n            this._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);\n        },\n\n        _onValidateCallbackSuccess: function(items, index, params, endpoint) {\n            var self = this,\n                nextIndex = index + 1,\n                validationDescriptor = this._getValidationDescriptor(items[index]);\n\n            this._validateFileOrBlobData(items[index], validationDescriptor)\n                .then(\n                function() {\n                    self._upload(items[index].id, params, endpoint);\n                    self._maybeProcessNextItemAfterOnValidateCallback(true, items, nextIndex, params, endpoint);\n                },\n                function() {\n                    self._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);\n                }\n            );\n        },\n\n        _prepareItemsForUpload: function(items, params, endpoint) {\n            if (items.length === 0) {\n                this._itemError(\"noFilesError\");\n                return;\n            }\n\n            var validationDescriptors = this._getValidationDescriptors(items),\n                buttonId = this._getButtonId(items[0].file),\n                button = this._getButton(buttonId);\n\n            this._handleCheckedCallback({\n                name: \"onValidateBatch\",\n                callback: qq.bind(this._options.callbacks.onValidateBatch, this, validationDescriptors, button),\n                onSuccess: qq.bind(this._onValidateBatchCallbackSuccess, this, validationDescriptors, items, params, endpoint, button),\n                onFailure: qq.bind(this._onValidateBatchCallbackFailure, this, items),\n                identifier: \"batch validation\"\n            });\n        },\n\n        _preventLeaveInProgress: function() {\n            var self = this;\n\n            this._disposeSupport.attach(window, \"beforeunload\", function(e) {\n                if (self.getInProgress()) {\n                    e = e || window.event;\n                    // for ie, ff\n                    e.returnValue = self._options.messages.onLeave;\n                    // for webkit\n                    return self._options.messages.onLeave;\n                }\n            });\n        },\n\n        // Attempts to refresh session data only if the `qq.Session` module exists\n        // and a session endpoint has been specified.  The `onSessionRequestComplete`\n        // callback will be invoked once the refresh is complete.\n        _refreshSessionData: function() {\n            var self = this,\n                options = this._options.session;\n\n            /* jshint eqnull:true */\n            if (qq.Session && this._options.session.endpoint != null) {\n                if (!this._session) {\n                    qq.extend(options, {cors: this._options.cors});\n\n                    options.log = qq.bind(this.log, this);\n                    options.addFileRecord = qq.bind(this._addCannedFile, this);\n\n                    this._session = new qq.Session(options);\n                }\n\n                setTimeout(function() {\n                    self._session.refresh().then(function(response, xhrOrXdr) {\n                        self._sessionRequestComplete();\n                        self._options.callbacks.onSessionRequestComplete(response, true, xhrOrXdr);\n\n                    }, function(response, xhrOrXdr) {\n\n                        self._options.callbacks.onSessionRequestComplete(response, false, xhrOrXdr);\n                    });\n                }, 0);\n            }\n        },\n\n        _sessionRequestComplete: function() {},\n\n        _setSize: function(id, newSize) {\n            this._uploadData.updateSize(id, newSize);\n            this._totalProgress && this._totalProgress.onNewSize(id);\n        },\n\n        _shouldAutoRetry: function(id) {\n            var uploadData = this._uploadData.retrieve({id: id});\n\n            /*jshint laxbreak: true */\n            if (!this._preventRetries[id]\n                && this._options.retry.enableAuto\n                && uploadData.status !== qq.status.PAUSED) {\n\n                if (this._autoRetries[id] === undefined) {\n                    this._autoRetries[id] = 0;\n                }\n\n                if (this._autoRetries[id] < this._options.retry.maxAutoAttempts) {\n                    this._autoRetries[id] += 1;\n                    return true;\n                }\n            }\n\n            return false;\n        },\n\n        _storeForLater: function(id) {\n            this._storedIds.push(id);\n        },\n\n        // Maps a file with the button that was used to select it.\n        _trackButton: function(id) {\n            var buttonId;\n\n            if (qq.supportedFeatures.ajaxUploading) {\n                buttonId = this._handler.getFile(id).qqButtonId;\n            }\n            else {\n                buttonId = this._getButtonId(this._handler.getInput(id));\n            }\n\n            if (buttonId) {\n                this._buttonIdsForFileIds[id] = buttonId;\n            }\n        },\n\n        _updateFormSupportAndParams: function(formElementOrId) {\n            this._options.form.element = formElementOrId;\n\n            this._formSupport = qq.FormSupport && new qq.FormSupport(\n                    this._options.form, qq.bind(this.uploadStoredFiles, this), qq.bind(this.log, this)\n                );\n\n            if (this._formSupport && this._formSupport.attachedToForm) {\n                this._paramsStore.addReadOnly(null, this._formSupport.getFormInputsAsObject);\n\n                this._options.autoUpload = this._formSupport.newAutoUpload;\n                if (this._formSupport.newEndpoint) {\n                    this.setEndpoint(this._formSupport.newEndpoint);\n                }\n            }\n        },\n\n        _upload: function(id, params, endpoint) {\n            var name = this.getName(id);\n\n            if (params) {\n                this.setParams(params, id);\n            }\n\n            if (endpoint) {\n                this.setEndpoint(endpoint, id);\n            }\n\n            this._handleCheckedCallback({\n                name: \"onSubmit\",\n                callback: qq.bind(this._options.callbacks.onSubmit, this, id, name),\n                onSuccess: qq.bind(this._onSubmitCallbackSuccess, this, id, name),\n                onFailure: qq.bind(this._fileOrBlobRejected, this, id, name),\n                identifier: id\n            });\n        },\n\n        _uploadFile: function(id) {\n            if (!this._handler.upload(id)) {\n                this._uploadData.setStatus(id, qq.status.QUEUED);\n            }\n        },\n\n        _uploadStoredFiles: function() {\n            var idToUpload, stillSubmitting,\n                self = this;\n\n            while (this._storedIds.length) {\n                idToUpload = this._storedIds.shift();\n                this._uploadFile(idToUpload);\n            }\n\n            // If we are still waiting for some files to clear validation, attempt to upload these again in a bit\n            stillSubmitting = this.getUploads({status: qq.status.SUBMITTING}).length;\n            if (stillSubmitting) {\n                qq.log(\"Still waiting for \" + stillSubmitting + \" files to clear submit queue. Will re-parse stored IDs array shortly.\");\n                setTimeout(function() {\n                    self._uploadStoredFiles();\n                }, 1000);\n            }\n        },\n\n        /**\n         * Performs some internal validation checks on an item, defined in the `validation` option.\n         *\n         * @param fileWrapper Wrapper containing a `file` along with an `id`\n         * @param validationDescriptor Normalized information about the item (`size`, `name`).\n         * @returns qq.Promise with appropriate callbacks invoked depending on the validity of the file\n         * @private\n         */\n        _validateFileOrBlobData: function(fileWrapper, validationDescriptor) {\n            var self = this,\n                file = (function() {\n                    if (fileWrapper.file instanceof qq.BlobProxy) {\n                        return fileWrapper.file.referenceBlob;\n                    }\n                    return fileWrapper.file;\n                }()),\n                name = validationDescriptor.name,\n                size = validationDescriptor.size,\n                buttonId = this._getButtonId(fileWrapper.file),\n                validationBase = this._getValidationBase(buttonId),\n                validityChecker = new qq.Promise();\n\n            validityChecker.then(\n                function() {},\n                function() {\n                    self._fileOrBlobRejected(fileWrapper.id, name);\n                });\n\n            if (qq.isFileOrInput(file) && !this._isAllowedExtension(validationBase.allowedExtensions, name)) {\n                this._itemError(\"typeError\", name, file);\n                return validityChecker.failure();\n            }\n\n            if (!this._options.validation.allowEmpty && size === 0) {\n                this._itemError(\"emptyError\", name, file);\n                return validityChecker.failure();\n            }\n\n            if (size > 0 && validationBase.sizeLimit && size > validationBase.sizeLimit) {\n                this._itemError(\"sizeError\", name, file);\n                return validityChecker.failure();\n            }\n\n            if (size > 0 && size < validationBase.minSizeLimit) {\n                this._itemError(\"minSizeError\", name, file);\n                return validityChecker.failure();\n            }\n\n            if (qq.ImageValidation && qq.supportedFeatures.imagePreviews && qq.isFile(file)) {\n                new qq.ImageValidation(file, qq.bind(self.log, self)).validate(validationBase.image).then(\n                    validityChecker.success,\n                    function(errorCode) {\n                        self._itemError(errorCode + \"ImageError\", name, file);\n                        validityChecker.failure();\n                    }\n                );\n            }\n            else {\n                validityChecker.success();\n            }\n\n            return validityChecker;\n        },\n\n        _wrapCallbacks: function() {\n            var self, safeCallback, prop;\n\n            self = this;\n\n            safeCallback = function(name, callback, args) {\n                var errorMsg;\n\n                try {\n                    return callback.apply(self, args);\n                }\n                catch (exception) {\n                    errorMsg = exception.message || exception.toString();\n                    self.log(\"Caught exception in '\" + name + \"' callback - \" + errorMsg, \"error\");\n                }\n            };\n\n            /* jshint forin: false, loopfunc: true */\n            for (prop in this._options.callbacks) {\n                (function() {\n                    var callbackName, callbackFunc;\n                    callbackName = prop;\n                    callbackFunc = self._options.callbacks[callbackName];\n                    self._options.callbacks[callbackName] = function() {\n                        return safeCallback(callbackName, callbackFunc, arguments);\n                    };\n                }());\n            }\n        }\n    };\n}());\n","/*globals qq*/\n(function() {\n    \"use strict\";\n\n    qq.FineUploaderBasic = function(o) {\n        var self = this;\n\n        // These options define FineUploaderBasic mode.\n        this._options = {\n            debug: false,\n            button: null,\n            multiple: true,\n            maxConnections: 3,\n            disableCancelForFormUploads: false,\n            autoUpload: true,\n            warnBeforeUnload: true,\n\n            request: {\n                customHeaders: {},\n                endpoint: \"/server/upload\",\n                filenameParam: \"qqfilename\",\n                forceMultipart: true,\n                inputName: \"qqfile\",\n                method: \"POST\",\n                omitDefaultParams: false,\n                params: {},\n                paramsInBody: true,\n                requireSuccessJson: true,\n                totalFileSizeName: \"qqtotalfilesize\",\n                uuidName: \"qquuid\"\n            },\n\n            validation: {\n                allowedExtensions: [],\n                sizeLimit: 0,\n                minSizeLimit: 0,\n                itemLimit: 0,\n                stopOnFirstInvalidFile: true,\n                acceptFiles: null,\n                image: {\n                    maxHeight: 0,\n                    maxWidth: 0,\n                    minHeight: 0,\n                    minWidth: 0\n                },\n                allowEmpty: false\n            },\n\n            callbacks: {\n                onSubmit: function(id, name) {},\n                onSubmitted: function(id, name) {},\n                onComplete: function(id, name, responseJSON, maybeXhr) {},\n                onAllComplete: function(successful, failed) {},\n                onCancel: function(id, name) {},\n                onUpload: function(id, name) {},\n                onUploadChunk: function(id, name, chunkData) {},\n                onUploadChunkSuccess: function(id, chunkData, responseJSON, xhr) {},\n                onResume: function(id, fileName, chunkData, customResumeData) {},\n                onProgress: function(id, name, loaded, total) {},\n                onTotalProgress: function(loaded, total) {},\n                onError: function(id, name, reason, maybeXhrOrXdr) {},\n                onAutoRetry: function(id, name, attemptNumber) {},\n                onManualRetry: function(id, name) {},\n                onValidateBatch: function(fileOrBlobData) {},\n                onValidate: function(fileOrBlobData) {},\n                onSubmitDelete: function(id) {},\n                onDelete: function(id) {},\n                onDeleteComplete: function(id, xhrOrXdr, isError) {},\n                onPasteReceived: function(blob) {},\n                onStatusChange: function(id, oldStatus, newStatus) {},\n                onSessionRequestComplete: function(response, success, xhrOrXdr) {}\n            },\n\n            messages: {\n                typeError: \"{file} has an invalid extension. Valid extension(s): {extensions}.\",\n                sizeError: \"{file} is too large, maximum file size is {sizeLimit}.\",\n                minSizeError: \"{file} is too small, minimum file size is {minSizeLimit}.\",\n                emptyError: \"{file} is empty, please select files again without it.\",\n                noFilesError: \"No files to upload.\",\n                tooManyItemsError: \"Too many items ({netItems}) would be uploaded.  Item limit is {itemLimit}.\",\n                maxHeightImageError: \"Image is too tall.\",\n                maxWidthImageError: \"Image is too wide.\",\n                minHeightImageError: \"Image is not tall enough.\",\n                minWidthImageError: \"Image is not wide enough.\",\n                retryFailTooManyItems: \"Retry failed - you have reached your file limit.\",\n                onLeave: \"The files are being uploaded, if you leave now the upload will be canceled.\",\n                unsupportedBrowserIos8Safari: \"Unrecoverable error - this browser does not permit file uploading of any kind due to serious bugs in iOS8 Safari.  Please use iOS8 Chrome until Apple fixes these issues.\"\n            },\n\n            retry: {\n                enableAuto: false,\n                maxAutoAttempts: 3,\n                autoAttemptDelay: 5,\n                preventRetryResponseProperty: \"preventRetry\"\n            },\n\n            classes: {\n                buttonHover: \"qq-upload-button-hover\",\n                buttonFocus: \"qq-upload-button-focus\"\n            },\n\n            chunking: {\n                enabled: false,\n                concurrent: {\n                    enabled: false\n                },\n                mandatory: false,\n                paramNames: {\n                    partIndex: \"qqpartindex\",\n                    partByteOffset: \"qqpartbyteoffset\",\n                    chunkSize: \"qqchunksize\",\n                    totalFileSize: \"qqtotalfilesize\",\n                    totalParts: \"qqtotalparts\"\n                },\n                partSize: function(id) {\n                    return 2000000;\n                },\n                // only relevant for traditional endpoints, only required when concurrent.enabled === true\n                success: {\n                    endpoint: null,\n\n                    headers: function(id) {\n                        return null;\n                    },\n\n                    jsonPayload: false,\n\n                    method: \"POST\",\n\n                    params: function(id) {\n                        return null;\n                    },\n\n                    resetOnStatus: []\n                }\n            },\n\n            resume: {\n                enabled: false,\n                recordsExpireIn: 7, //days\n                paramNames: {\n                    resuming: \"qqresume\"\n                },\n                customKeys: function(fileId) {\n                    return [];\n                }\n            },\n\n            formatFileName: function(fileOrBlobName) {\n                return fileOrBlobName;\n            },\n\n            text: {\n                defaultResponseError: \"Upload failure reason unknown\",\n                fileInputTitle: \"file input\",\n                sizeSymbols: [\"kB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\"]\n            },\n\n            deleteFile: {\n                enabled: false,\n                method: \"DELETE\",\n                endpoint: \"/server/upload\",\n                customHeaders: {},\n                params: {}\n            },\n\n            cors: {\n                expected: false,\n                sendCredentials: false,\n                allowXdr: false\n            },\n\n            blobs: {\n                defaultName: \"misc_data\"\n            },\n\n            paste: {\n                targetElement: null,\n                defaultName: \"pasted_image\"\n            },\n\n            camera: {\n                ios: false,\n\n                // if ios is true: button is null means target the default button, otherwise target the button specified\n                button: null\n            },\n\n            // This refers to additional upload buttons to be handled by Fine Uploader.\n            // Each element is an object, containing `element` as the only required\n            // property.  The `element` must be a container that will ultimately\n            // contain an invisible `<input type=\"file\">` created by Fine Uploader.\n            // Optional properties of each object include `multiple`, `validation`,\n            // and `folders`.\n            extraButtons: [],\n\n            // Depends on the session module.  Used to query the server for an initial file list\n            // during initialization and optionally after a `reset`.\n            session: {\n                endpoint: null,\n                params: {},\n                customHeaders: {},\n                refreshOnReset: true\n            },\n\n            // Send parameters associated with an existing form along with the files\n            form: {\n                // Element ID, HTMLElement, or null\n                element: \"qq-form\",\n\n                // Overrides the base `autoUpload`, unless `element` is null.\n                autoUpload: false,\n\n                // true = upload files on form submission (and squelch submit event)\n                interceptSubmit: true\n            },\n\n            // scale images client side, upload a new file for each scaled version\n            scaling: {\n                customResizer: null,\n\n                // send the original file as well\n                sendOriginal: true,\n\n                // fox orientation for scaled images\n                orient: true,\n\n                // If null, scaled image type will match reference image type.  This value will be referred to\n                // for any size record that does not specific a type.\n                defaultType: null,\n\n                defaultQuality: 80,\n\n                failureText: \"Failed to scale\",\n\n                includeExif: false,\n\n                // metadata about each requested scaled version\n                sizes: []\n            },\n\n            workarounds: {\n                iosEmptyVideos: true,\n                ios8SafariUploads: true,\n                ios8BrowserCrash: false\n            }\n        };\n\n        // Replace any default options with user defined ones\n        qq.extend(this._options, o, true);\n\n        this._buttons = [];\n        this._extraButtonSpecs = {};\n        this._buttonIdsForFileIds = [];\n\n        this._wrapCallbacks();\n        this._disposeSupport =  new qq.DisposeSupport();\n\n        this._storedIds = [];\n        this._autoRetries = [];\n        this._retryTimeouts = [];\n        this._preventRetries = [];\n        this._thumbnailUrls = [];\n\n        this._netUploadedOrQueued = 0;\n        this._netUploaded = 0;\n        this._uploadData = this._createUploadDataTracker();\n\n        this._initFormSupportAndParams();\n\n        this._customHeadersStore = this._createStore(this._options.request.customHeaders);\n        this._deleteFileCustomHeadersStore = this._createStore(this._options.deleteFile.customHeaders);\n\n        this._deleteFileParamsStore = this._createStore(this._options.deleteFile.params);\n\n        this._endpointStore = this._createStore(this._options.request.endpoint);\n        this._deleteFileEndpointStore = this._createStore(this._options.deleteFile.endpoint);\n\n        this._handler = this._createUploadHandler();\n\n        this._deleteHandler = qq.DeleteFileAjaxRequester && this._createDeleteHandler();\n\n        if (this._options.button) {\n            this._defaultButtonId = this._createUploadButton({\n                element: this._options.button,\n                title: this._options.text.fileInputTitle\n            }).getButtonId();\n        }\n\n        this._generateExtraButtonSpecs();\n\n        this._handleCameraAccess();\n\n        if (this._options.paste.targetElement) {\n            if (qq.PasteSupport) {\n                this._pasteHandler = this._createPasteHandler();\n            }\n            else {\n                this.log(\"Paste support module not found\", \"error\");\n            }\n        }\n\n        this._options.warnBeforeUnload && this._preventLeaveInProgress();\n\n        this._imageGenerator = qq.ImageGenerator && new qq.ImageGenerator(qq.bind(this.log, this));\n        this._refreshSessionData();\n\n        this._succeededSinceLastAllComplete = [];\n        this._failedSinceLastAllComplete = [];\n\n        this._scaler = (qq.Scaler && new qq.Scaler(this._options.scaling, qq.bind(this.log, this))) || {};\n        if (this._scaler.enabled) {\n            this._customNewFileHandler = qq.bind(this._scaler.handleNewFile, this._scaler);\n        }\n\n        if (qq.TotalProgress && qq.supportedFeatures.progressBar) {\n            this._totalProgress = new qq.TotalProgress(\n                qq.bind(this._onTotalProgress, this),\n\n                function(id) {\n                    var entry = self._uploadData.retrieve({id: id});\n                    return (entry && entry.size) || 0;\n                }\n            );\n        }\n\n        this._currentItemLimit = this._options.validation.itemLimit;\n\n        this._customResumeDataStore = this._createStore();\n    };\n\n    // Define the private & public API methods.\n    qq.FineUploaderBasic.prototype = qq.basePublicApi;\n    qq.extend(qq.FineUploaderBasic.prototype, qq.basePrivateApi);\n}());\n","/*globals qq, XDomainRequest*/\n/** Generic class for sending non-upload ajax requests and handling the associated responses **/\nqq.AjaxRequester = function(o) {\n    \"use strict\";\n\n    var log, shouldParamsBeInQueryString,\n        queue = [],\n        requestData = {},\n        options = {\n            acceptHeader: null,\n            validMethods: [\"PATCH\", \"POST\", \"PUT\"],\n            method: \"POST\",\n            contentType: \"application/x-www-form-urlencoded\",\n            maxConnections: 3,\n            customHeaders: {},\n            endpointStore: {},\n            paramsStore: {},\n            mandatedParams: {},\n            allowXRequestedWithAndCacheControl: true,\n            successfulResponseCodes: {\n                DELETE: [200, 202, 204],\n                PATCH: [200, 201, 202, 203, 204],\n                POST: [200, 201, 202, 203, 204],\n                PUT: [200, 201, 202, 203, 204],\n                GET: [200]\n            },\n            cors: {\n                expected: false,\n                sendCredentials: false\n            },\n            log: function(str, level) {},\n            onSend: function(id) {},\n            onComplete: function(id, xhrOrXdr, isError) {},\n            onProgress: null\n        };\n\n    qq.extend(options, o);\n    log = options.log;\n\n    if (qq.indexOf(options.validMethods, options.method) < 0) {\n        throw new Error(\"'\" + options.method + \"' is not a supported method for this type of request!\");\n    }\n\n    // [Simple methods](http://www.w3.org/TR/cors/#simple-method)\n    // are defined by the W3C in the CORS spec as a list of methods that, in part,\n    // make a CORS request eligible to be exempt from preflighting.\n    function isSimpleMethod() {\n        return qq.indexOf([\"GET\", \"POST\", \"HEAD\"], options.method) >= 0;\n    }\n\n    // [Simple headers](http://www.w3.org/TR/cors/#simple-header)\n    // are defined by the W3C in the CORS spec as a list of headers that, in part,\n    // make a CORS request eligible to be exempt from preflighting.\n    function containsNonSimpleHeaders(headers) {\n        var containsNonSimple = false;\n\n        qq.each(containsNonSimple, function(idx, header) {\n            if (qq.indexOf([\"Accept\", \"Accept-Language\", \"Content-Language\", \"Content-Type\"], header) < 0) {\n                containsNonSimple = true;\n                return false;\n            }\n        });\n\n        return containsNonSimple;\n    }\n\n    function isXdr(xhr) {\n        //The `withCredentials` test is a commonly accepted way to determine if XHR supports CORS.\n        return options.cors.expected && xhr.withCredentials === undefined;\n    }\n\n    // Returns either a new `XMLHttpRequest` or `XDomainRequest` instance.\n    function getCorsAjaxTransport() {\n        var xhrOrXdr;\n\n        if (window.XMLHttpRequest || window.ActiveXObject) {\n            xhrOrXdr = qq.createXhrInstance();\n\n            if (xhrOrXdr.withCredentials === undefined) {\n                xhrOrXdr = new XDomainRequest();\n                // Workaround for XDR bug in IE9 - https://social.msdn.microsoft.com/Forums/ie/en-US/30ef3add-767c-4436-b8a9-f1ca19b4812e/ie9-rtm-xdomainrequest-issued-requests-may-abort-if-all-event-handlers-not-specified?forum=iewebdevelopment\n                xhrOrXdr.onload = function() {};\n                xhrOrXdr.onerror = function() {};\n                xhrOrXdr.ontimeout = function() {};\n                xhrOrXdr.onprogress = function() {};\n            }\n        }\n\n        return xhrOrXdr;\n    }\n\n    // Returns either a new XHR/XDR instance, or an existing one for the associated `File` or `Blob`.\n    function getXhrOrXdr(id, suppliedXhr) {\n        var xhrOrXdr = requestData[id] && requestData[id].xhr;\n\n        if (!xhrOrXdr) {\n            if (suppliedXhr) {\n                xhrOrXdr = suppliedXhr;\n            }\n            else {\n                if (options.cors.expected) {\n                    xhrOrXdr = getCorsAjaxTransport();\n                }\n                else {\n                    xhrOrXdr = qq.createXhrInstance();\n                }\n            }\n\n            requestData[id].xhr = xhrOrXdr;\n        }\n\n        return xhrOrXdr;\n    }\n\n    // Removes element from queue, sends next request\n    function dequeue(id) {\n        var i = qq.indexOf(queue, id),\n            max = options.maxConnections,\n            nextId;\n\n        delete requestData[id];\n        queue.splice(i, 1);\n\n        if (queue.length >= max && i < max) {\n            nextId = queue[max - 1];\n            sendRequest(nextId);\n        }\n    }\n\n    function onComplete(id, xdrError) {\n        var xhr = getXhrOrXdr(id),\n            method = options.method,\n            isError = xdrError === true;\n\n        dequeue(id);\n\n        if (isError) {\n            log(method + \" request for \" + id + \" has failed\", \"error\");\n        }\n        else if (!isXdr(xhr) && !isResponseSuccessful(xhr.status)) {\n            isError = true;\n            log(method + \" request for \" + id + \" has failed - response code \" + xhr.status, \"error\");\n        }\n\n        options.onComplete(id, xhr, isError);\n    }\n\n    function getParams(id) {\n        var onDemandParams = requestData[id].additionalParams,\n            mandatedParams = options.mandatedParams,\n            params;\n\n        if (options.paramsStore.get) {\n            params = options.paramsStore.get(id);\n        }\n\n        if (onDemandParams) {\n            qq.each(onDemandParams, function(name, val) {\n                params = params || {};\n                params[name] = val;\n            });\n        }\n\n        if (mandatedParams) {\n            qq.each(mandatedParams, function(name, val) {\n                params = params || {};\n                params[name] = val;\n            });\n        }\n\n        return params;\n    }\n\n    function sendRequest(id, optXhr) {\n        var xhr = getXhrOrXdr(id, optXhr),\n            method = options.method,\n            params = getParams(id),\n            payload = requestData[id].payload,\n            url;\n\n        options.onSend(id);\n\n        url = createUrl(id, params, requestData[id].additionalQueryParams);\n\n        // XDR and XHR status detection APIs differ a bit.\n        if (isXdr(xhr)) {\n            xhr.onload = getXdrLoadHandler(id);\n            xhr.onerror = getXdrErrorHandler(id);\n        }\n        else {\n            xhr.onreadystatechange = getXhrReadyStateChangeHandler(id);\n        }\n\n        registerForUploadProgress(id);\n\n        // The last parameter is assumed to be ignored if we are actually using `XDomainRequest`.\n        xhr.open(method, url, true);\n\n        // Instruct the transport to send cookies along with the CORS request,\n        // unless we are using `XDomainRequest`, which is not capable of this.\n        if (options.cors.expected && options.cors.sendCredentials && !isXdr(xhr)) {\n            xhr.withCredentials = true;\n        }\n\n        setHeaders(id);\n\n        log(\"Sending \" + method + \" request for \" + id);\n\n        if (payload) {\n            xhr.send(payload);\n        }\n        else if (shouldParamsBeInQueryString || !params) {\n            xhr.send();\n        }\n        else if (params && options.contentType && options.contentType.toLowerCase().indexOf(\"application/x-www-form-urlencoded\") >= 0) {\n            xhr.send(qq.obj2url(params, \"\"));\n        }\n        else if (params && options.contentType && options.contentType.toLowerCase().indexOf(\"application/json\") >= 0) {\n            xhr.send(JSON.stringify(params));\n        }\n        else {\n            xhr.send(params);\n        }\n\n        return xhr;\n    }\n\n    function createUrl(id, params, additionalQueryParams) {\n        var endpoint = options.endpointStore.get(id),\n            addToPath = requestData[id].addToPath;\n\n        /*jshint -W116,-W041 */\n        if (addToPath != undefined) {\n            endpoint += \"/\" + addToPath;\n        }\n\n        if (shouldParamsBeInQueryString && params) {\n            endpoint = qq.obj2url(params, endpoint);\n        }\n\n        if (additionalQueryParams) {\n            endpoint = qq.obj2url(additionalQueryParams, endpoint);\n        }\n\n        return endpoint;\n    }\n\n    // Invoked by the UA to indicate a number of possible states that describe\n    // a live `XMLHttpRequest` transport.\n    function getXhrReadyStateChangeHandler(id) {\n        return function() {\n            if (getXhrOrXdr(id).readyState === 4) {\n                onComplete(id);\n            }\n        };\n    }\n\n    function registerForUploadProgress(id) {\n        var onProgress = options.onProgress;\n\n        if (onProgress) {\n            getXhrOrXdr(id).upload.onprogress = function(e) {\n                if (e.lengthComputable) {\n                    onProgress(id, e.loaded, e.total);\n                }\n            };\n        }\n    }\n\n    // This will be called by IE to indicate **success** for an associated\n    // `XDomainRequest` transported request.\n    function getXdrLoadHandler(id) {\n        return function() {\n            onComplete(id);\n        };\n    }\n\n    // This will be called by IE to indicate **failure** for an associated\n    // `XDomainRequest` transported request.\n    function getXdrErrorHandler(id) {\n        return function() {\n            onComplete(id, true);\n        };\n    }\n\n    function setHeaders(id) {\n        var xhr = getXhrOrXdr(id),\n            customHeaders = options.customHeaders,\n            onDemandHeaders = requestData[id].additionalHeaders || {},\n            method = options.method,\n            allHeaders = {};\n\n        // If XDomainRequest is being used, we can't set headers, so just ignore this block.\n        if (!isXdr(xhr)) {\n            options.acceptHeader && xhr.setRequestHeader(\"Accept\", options.acceptHeader);\n\n            // Only attempt to add X-Requested-With & Cache-Control if permitted\n            if (options.allowXRequestedWithAndCacheControl) {\n                // Do not add X-Requested-With & Cache-Control if this is a cross-origin request\n                // OR the cross-origin request contains a non-simple method or header.\n                // This is done to ensure a preflight is not triggered exclusively based on the\n                // addition of these 2 non-simple headers.\n                if (!options.cors.expected || (!isSimpleMethod() || containsNonSimpleHeaders(customHeaders))) {\n                    xhr.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\n                    xhr.setRequestHeader(\"Cache-Control\", \"no-cache\");\n                }\n            }\n\n            if (options.contentType && (method === \"POST\" || method === \"PUT\")) {\n                xhr.setRequestHeader(\"Content-Type\", options.contentType);\n            }\n\n            qq.extend(allHeaders, qq.isFunction(customHeaders) ? customHeaders(id) : customHeaders);\n            qq.extend(allHeaders, onDemandHeaders);\n\n            qq.each(allHeaders, function(name, val) {\n                xhr.setRequestHeader(name, val);\n            });\n        }\n    }\n\n    function isResponseSuccessful(responseCode) {\n        return qq.indexOf(options.successfulResponseCodes[options.method], responseCode) >= 0;\n    }\n\n    function prepareToSend(id, optXhr, addToPath, additionalParams, additionalQueryParams, additionalHeaders, payload) {\n        requestData[id] = {\n            addToPath: addToPath,\n            additionalParams: additionalParams,\n            additionalQueryParams: additionalQueryParams,\n            additionalHeaders: additionalHeaders,\n            payload: payload\n        };\n\n        var len = queue.push(id);\n\n        // if too many active connections, wait...\n        if (len <= options.maxConnections) {\n            return sendRequest(id, optXhr);\n        }\n    }\n\n    shouldParamsBeInQueryString = options.method === \"GET\" || options.method === \"DELETE\";\n\n    qq.extend(this, {\n        // Start the process of sending the request.  The ID refers to the file associated with the request.\n        initTransport: function(id) {\n            var path, params, headers, payload, cacheBuster, additionalQueryParams;\n\n            return {\n                // Optionally specify the end of the endpoint path for the request.\n                withPath: function(appendToPath) {\n                    path = appendToPath;\n                    return this;\n                },\n\n                // Optionally specify additional parameters to send along with the request.\n                // These will be added to the query string for GET/DELETE requests or the payload\n                // for POST/PUT requests.  The Content-Type of the request will be used to determine\n                // how these parameters should be formatted as well.\n                withParams: function(additionalParams) {\n                    params = additionalParams;\n                    return this;\n                },\n\n                withQueryParams: function(_additionalQueryParams_) {\n                    additionalQueryParams = _additionalQueryParams_;\n                    return this;\n                },\n\n                // Optionally specify additional headers to send along with the request.\n                withHeaders: function(additionalHeaders) {\n                    headers = additionalHeaders;\n                    return this;\n                },\n\n                // Optionally specify a payload/body for the request.\n                withPayload: function(thePayload) {\n                    payload = thePayload;\n                    return this;\n                },\n\n                // Appends a cache buster (timestamp) to the request URL as a query parameter (only if GET or DELETE)\n                withCacheBuster: function() {\n                    cacheBuster = true;\n                    return this;\n                },\n\n                // Send the constructed request.\n                send: function(optXhr) {\n                    if (cacheBuster && qq.indexOf([\"GET\", \"DELETE\"], options.method) >= 0) {\n                        params.qqtimestamp = new Date().getTime();\n                    }\n\n                    return prepareToSend(id, optXhr, path, params, additionalQueryParams, headers, payload);\n                }\n            };\n        },\n\n        canceled: function(id) {\n            dequeue(id);\n        }\n    });\n};\n","/* globals qq */\n/**\n * Common upload handler functions.\n *\n * @constructor\n */\nqq.UploadHandler = function(spec) {\n    \"use strict\";\n\n    var proxy = spec.proxy,\n        fileState = {},\n        onCancel = proxy.onCancel,\n        getName = proxy.getName;\n\n    qq.extend(this, {\n        add: function(id, fileItem) {\n            fileState[id] = fileItem;\n            fileState[id].temp = {};\n        },\n\n        cancel: function(id) {\n            var self = this,\n                cancelFinalizationEffort = new qq.Promise(),\n                onCancelRetVal = onCancel(id, getName(id), cancelFinalizationEffort);\n\n            onCancelRetVal.then(function() {\n                if (self.isValid(id)) {\n                    fileState[id].canceled = true;\n                    self.expunge(id);\n                }\n                cancelFinalizationEffort.success();\n            });\n        },\n\n        expunge: function(id) {\n            delete fileState[id];\n        },\n\n        getThirdPartyFileId: function(id) {\n            return fileState[id].key;\n        },\n\n        isValid: function(id) {\n            return fileState[id] !== undefined;\n        },\n\n        reset: function() {\n            fileState = {};\n        },\n\n        _getFileState: function(id) {\n            return fileState[id];\n        },\n\n        _setThirdPartyFileId: function(id, thirdPartyFileId) {\n            fileState[id].key = thirdPartyFileId;\n        },\n\n        _wasCanceled: function(id) {\n            return !!fileState[id].canceled;\n        }\n    });\n};\n","/*globals qq*/\n/**\n * Base upload handler module.  Controls more specific handlers.\n *\n * @param o Options.  Passed along to the specific handler submodule as well.\n * @param namespace [optional] Namespace for the specific handler.\n */\nqq.UploadHandlerController = function(o, namespace) {\n    \"use strict\";\n\n    var controller = this,\n        chunkingPossible = false,\n        concurrentChunkingPossible = false,\n        chunking, preventRetryResponse, log, handler,\n\n    options = {\n        paramsStore: {},\n        maxConnections: 3, // maximum number of concurrent uploads\n        chunking: {\n            enabled: false,\n            multiple: {\n                enabled: false\n            }\n        },\n        log: function(str, level) {},\n        onProgress: function(id, fileName, loaded, total) {},\n        onComplete: function(id, fileName, response, xhr) {},\n        onCancel: function(id, fileName) {},\n        onUploadPrep: function(id) {}, // Called if non-trivial operations will be performed before onUpload\n        onUpload: function(id, fileName) {},\n        onUploadChunk: function(id, fileName, chunkData) {},\n        onUploadChunkSuccess: function(id, chunkData, response, xhr) {},\n        onAutoRetry: function(id, fileName, response, xhr) {},\n        onResume: function(id, fileName, chunkData, customResumeData) {},\n        onUuidChanged: function(id, newUuid) {},\n        getName: function(id) {},\n        setSize: function(id, newSize) {},\n        isQueued: function(id) {},\n        getIdsInProxyGroup: function(id) {},\n        getIdsInBatch: function(id) {},\n        isInProgress: function(id) {}\n    },\n\n    chunked = {\n        // Called when each chunk has uploaded successfully\n        done: function(id, chunkIdx, response, xhr) {\n            var chunkData = handler._getChunkData(id, chunkIdx);\n\n            handler._getFileState(id).attemptingResume = false;\n\n            delete handler._getFileState(id).temp.chunkProgress[chunkIdx];\n            handler._getFileState(id).loaded += chunkData.size;\n\n            options.onUploadChunkSuccess(id, handler._getChunkDataForCallback(chunkData), response, xhr);\n        },\n\n        // Called when all chunks have been successfully uploaded and we want to ask the handler to perform any\n        // logic associated with closing out the file, such as combining the chunks.\n        finalize: function(id) {\n            var size = options.getSize(id),\n                name = options.getName(id);\n\n            log(\"All chunks have been uploaded for \" + id + \" - finalizing....\");\n            handler.finalizeChunks(id).then(\n                function(response, xhr) {\n                    log(\"Finalize successful for \" + id);\n\n                    var normaizedResponse = upload.normalizeResponse(response, true);\n\n                    options.onProgress(id, name, size, size);\n                    handler._maybeDeletePersistedChunkData(id);\n                    upload.cleanup(id, normaizedResponse, xhr);\n                },\n                function(response, xhr) {\n                    var normalizedResponse = upload.normalizeResponse(response, false);\n\n                    log(\"Problem finalizing chunks for file ID \" + id + \" - \" + normalizedResponse.error, \"error\");\n\n                    if (\n                        normalizedResponse.reset ||\n                        (xhr && options.chunking.success.resetOnStatus.indexOf(xhr.status) >= 0)\n                    ) {\n                        chunked.reset(id);\n                    }\n\n                    if (!options.onAutoRetry(id, name, normalizedResponse, xhr)) {\n                        upload.cleanup(id, normalizedResponse, xhr);\n                    }\n                }\n            );\n        },\n\n        handleFailure: function(chunkIdx, id, response, xhr) {\n            var name = options.getName(id);\n\n            log(\"Chunked upload request failed for \" + id + \", chunk \" + chunkIdx);\n\n            handler.clearCachedChunk(id, chunkIdx);\n\n            var responseToReport = upload.normalizeResponse(response, false),\n                inProgressIdx;\n\n            if (responseToReport.reset) {\n                chunked.reset(id);\n            }\n            else {\n                var inProgressChunksArray = handler._getFileState(id).chunking.inProgress;\n\n                inProgressIdx = inProgressChunksArray ? qq.indexOf(inProgressChunksArray, chunkIdx) : -1;\n                if (inProgressIdx >= 0) {\n                    handler._getFileState(id).chunking.inProgress.splice(inProgressIdx, 1);\n                    handler._getFileState(id).chunking.remaining.unshift(chunkIdx);\n                }\n            }\n\n            // We may have aborted all other in-progress chunks for this file due to a failure.\n            // If so, ignore the failures associated with those aborts.\n            if (!handler._getFileState(id).temp.ignoreFailure) {\n                // If this chunk has failed, we want to ignore all other failures of currently in-progress\n                // chunks since they will be explicitly aborted\n                if (concurrentChunkingPossible) {\n                    handler._getFileState(id).temp.ignoreFailure = true;\n\n                    log(qq.format(\"Going to attempt to abort these chunks: {}. These are currently in-progress: {}.\", JSON.stringify(Object.keys(handler._getXhrs(id))), JSON.stringify(handler._getFileState(id).chunking.inProgress)));\n                    qq.each(handler._getXhrs(id), function(ckid, ckXhr) {\n                        log(qq.format(\"Attempting to abort file {}.{}. XHR readyState {}. \", id, ckid, ckXhr.readyState));\n                        ckXhr.abort();\n                        // Flag the transport, in case we are waiting for some other async operation\n                        // to complete before attempting to upload the chunk\n                        ckXhr._cancelled = true;\n                    });\n\n                    // We must indicate that all aborted chunks are no longer in progress\n                    handler.moveInProgressToRemaining(id);\n\n                    // Free up any connections used by these chunks, but don't allow any\n                    // other files to take up the connections (until we have exhausted all auto-retries)\n                    connectionManager.free(id, true);\n                }\n\n                if (!options.onAutoRetry(id, name, responseToReport, xhr)) {\n                    // If one chunk fails, abort all of the others to avoid odd race conditions that occur\n                    // if a chunk succeeds immediately after one fails before we have determined if the upload\n                    // is a failure or not.\n                    upload.cleanup(id, responseToReport, xhr);\n                }\n            }\n        },\n\n        hasMoreParts: function(id) {\n            return !!handler._getFileState(id).chunking.remaining.length;\n        },\n\n        nextPart: function(id) {\n            var nextIdx = handler._getFileState(id).chunking.remaining.shift();\n\n            if (nextIdx >= handler._getTotalChunks(id)) {\n                nextIdx = null;\n            }\n\n            return nextIdx;\n        },\n\n        reset: function(id) {\n            log(\"Server or callback has ordered chunking effort to be restarted on next attempt for item ID \" + id, \"error\");\n\n            handler._maybeDeletePersistedChunkData(id);\n            handler.reevaluateChunking(id);\n            handler._getFileState(id).loaded = 0;\n            handler._getFileState(id).attemptingResume = false;\n        },\n\n        sendNext: function(id) {\n            var size = options.getSize(id),\n                name = options.getName(id),\n                chunkIdx = chunked.nextPart(id),\n                chunkData = handler._getChunkData(id, chunkIdx),\n                fileState = handler._getFileState(id),\n                resuming = fileState.attemptingResume,\n                inProgressChunks = fileState.chunking.inProgress || [];\n\n            if (fileState.loaded == null) {\n                fileState.loaded = 0;\n            }\n\n            // Don't follow-through with the resume attempt if the integrator returns false from onResume\n            if (resuming && options.onResume(id, name, chunkData, fileState.customResumeData) === false) {\n                chunked.reset(id);\n                chunkIdx = chunked.nextPart(id);\n                chunkData = handler._getChunkData(id, chunkIdx);\n                resuming = false;\n            }\n\n            // If all chunks have already uploaded successfully, we must be re-attempting the finalize step.\n            if (chunkIdx == null && inProgressChunks.length === 0) {\n                chunked.finalize(id);\n            }\n\n            // Send the next chunk\n            else {\n                inProgressChunks.push(chunkIdx);\n                handler._getFileState(id).chunking.inProgress = inProgressChunks;\n\n                if (concurrentChunkingPossible) {\n                    connectionManager.open(id, chunkIdx);\n                }\n\n                if (concurrentChunkingPossible && connectionManager.available() && handler._getFileState(id).chunking.remaining.length) {\n                    chunked.sendNext(id);\n                }\n\n                if (chunkData.blob.size === 0) {\n                    log(qq.format(\"Chunk {} for file {} will not be uploaded, zero sized chunk.\", chunkIdx, id), \"error\");\n                    chunked.handleFailure(chunkIdx, id, \"File is no longer available\", null);\n                }\n\n                var onUploadChunkPromise = options.onUploadChunk(id, name, handler._getChunkDataForCallback(chunkData));\n\n                onUploadChunkPromise.then(\n                    function(requestOverrides) {\n                        if (!options.isInProgress(id)) {\n                            log(qq.format(\"Not sending chunked upload request for item {}.{} - no longer in progress.\", id, chunkIdx));\n                        }\n                        else {\n                            log(qq.format(\"Sending chunked upload request for item {}.{}, bytes {}-{} of {}.\", id, chunkIdx, chunkData.start + 1, chunkData.end, size));\n\n                            var uploadChunkData = {\n                                chunkIdx: chunkIdx,\n                                id: id,\n                                overrides: requestOverrides,\n                                resuming: resuming\n                            };\n\n                            handler.uploadChunk(uploadChunkData).then(\n                                // upload chunk success\n                                function success(response, xhr) {\n                                    log(\"Chunked upload request succeeded for \" + id + \", chunk \" + chunkIdx);\n\n                                    handler.clearCachedChunk(id, chunkIdx);\n\n                                    var inProgressChunks = handler._getFileState(id).chunking.inProgress || [],\n                                        responseToReport = upload.normalizeResponse(response, true),\n                                        inProgressChunkIdx = qq.indexOf(inProgressChunks, chunkIdx);\n\n                                    log(qq.format(\"Chunk {} for file {} uploaded successfully.\", chunkIdx, id));\n\n                                    chunked.done(id, chunkIdx, responseToReport, xhr);\n\n                                    if (inProgressChunkIdx >= 0) {\n                                        inProgressChunks.splice(inProgressChunkIdx, 1);\n                                    }\n\n                                    handler._maybePersistChunkedState(id);\n\n                                    if (!chunked.hasMoreParts(id) && inProgressChunks.length === 0) {\n                                        chunked.finalize(id);\n                                    }\n                                    else if (chunked.hasMoreParts(id)) {\n                                        chunked.sendNext(id);\n                                    }\n                                    else {\n                                        log(qq.format(\"File ID {} has no more chunks to send and these chunk indexes are still marked as in-progress: {}\", id, JSON.stringify(inProgressChunks)));\n                                    }\n                                },\n\n                                // upload chunk failure\n                                function failure(response, xhr) {\n                                    chunked.handleFailure(chunkIdx, id, response, xhr);\n                                }\n                            )\n                                .done(function () {\n                                    handler.clearXhr(id, chunkIdx);\n                                });\n                        }\n                    },\n\n                    function(error) {\n                        chunked.handleFailure(chunkIdx, id, error, null);\n                    }\n                );\n            }\n        }\n    },\n\n    connectionManager = {\n        _open: [],\n        _openChunks: {},\n        _waiting: [],\n\n        available: function() {\n            var max = options.maxConnections,\n                openChunkEntriesCount = 0,\n                openChunksCount = 0;\n\n            qq.each(connectionManager._openChunks, function(fileId, openChunkIndexes) {\n                openChunkEntriesCount++;\n                openChunksCount += openChunkIndexes.length;\n            });\n\n            return max - (connectionManager._open.length - openChunkEntriesCount + openChunksCount);\n        },\n\n        /**\n         * Removes element from queue, starts upload of next\n         */\n        free: function(id, dontAllowNext) {\n            var allowNext = !dontAllowNext,\n                waitingIndex = qq.indexOf(connectionManager._waiting, id),\n                connectionsIndex = qq.indexOf(connectionManager._open, id),\n                nextId;\n\n            delete connectionManager._openChunks[id];\n\n            if (upload.getProxyOrBlob(id) instanceof qq.BlobProxy) {\n                log(\"Generated blob upload has ended for \" + id + \", disposing generated blob.\");\n                delete handler._getFileState(id).file;\n            }\n\n            // If this file was not consuming a connection, it was just waiting, so remove it from the waiting array\n            if (waitingIndex >= 0) {\n                connectionManager._waiting.splice(waitingIndex, 1);\n            }\n            // If this file was consuming a connection, allow the next file to be uploaded\n            else if (allowNext && connectionsIndex >= 0) {\n                connectionManager._open.splice(connectionsIndex, 1);\n\n                nextId = connectionManager._waiting.shift();\n                if (nextId >= 0) {\n                    connectionManager._open.push(nextId);\n                    upload.start(nextId);\n                }\n            }\n        },\n\n        getWaitingOrConnected: function() {\n            var waitingOrConnected = [];\n\n            // Chunked files may have multiple connections open per chunk (if concurrent chunking is enabled)\n            // We need to grab the file ID of any file that has at least one chunk consuming a connection.\n            qq.each(connectionManager._openChunks, function(fileId, chunks) {\n                if (chunks && chunks.length) {\n                    waitingOrConnected.push(parseInt(fileId));\n                }\n            });\n\n            // For non-chunked files, only one connection will be consumed per file.\n            // This is where we aggregate those file IDs.\n            qq.each(connectionManager._open, function(idx, fileId) {\n                if (!connectionManager._openChunks[fileId]) {\n                    waitingOrConnected.push(parseInt(fileId));\n                }\n            });\n\n            // There may be files waiting for a connection.\n            waitingOrConnected = waitingOrConnected.concat(connectionManager._waiting);\n\n            return waitingOrConnected;\n        },\n\n        isUsingConnection: function(id) {\n            return qq.indexOf(connectionManager._open, id) >= 0;\n        },\n\n        open: function(id, chunkIdx) {\n            if (chunkIdx == null) {\n                connectionManager._waiting.push(id);\n            }\n\n            if (connectionManager.available()) {\n                if (chunkIdx == null) {\n                    connectionManager._waiting.pop();\n                    connectionManager._open.push(id);\n                }\n                else {\n                    (function() {\n                        var openChunksEntry = connectionManager._openChunks[id] || [];\n                        openChunksEntry.push(chunkIdx);\n                        connectionManager._openChunks[id] = openChunksEntry;\n                    }());\n                }\n\n                return true;\n            }\n\n            return false;\n        },\n\n        reset: function() {\n            connectionManager._waiting = [];\n            connectionManager._open = [];\n        }\n    },\n\n    simple = {\n        send: function(id, name) {\n            var fileState = handler._getFileState(id);\n\n            if (!fileState) {\n                log(\"Ignoring send request as this upload may have been cancelled, File ID \" + id, \"warn\");\n                return;\n            }\n\n            fileState.loaded = 0;\n\n            log(\"Sending simple upload request for \" + id);\n            handler.uploadFile(id).then(\n                function(response, optXhr) {\n                    log(\"Simple upload request succeeded for \" + id);\n\n                    var responseToReport = upload.normalizeResponse(response, true),\n                        size = options.getSize(id);\n\n                    options.onProgress(id, name, size, size);\n                    upload.maybeNewUuid(id, responseToReport);\n                    upload.cleanup(id, responseToReport, optXhr);\n                },\n\n                function(response, optXhr) {\n                    log(\"Simple upload request failed for \" + id);\n\n                    var responseToReport = upload.normalizeResponse(response, false);\n\n                    if (!options.onAutoRetry(id, name, responseToReport, optXhr)) {\n                        upload.cleanup(id, responseToReport, optXhr);\n                    }\n                }\n            );\n        }\n    },\n\n    upload = {\n        cancel: function(id) {\n            log(\"Cancelling \" + id);\n            options.paramsStore.remove(id);\n            connectionManager.free(id);\n        },\n\n        cleanup: function(id, response, optXhr) {\n            var name = options.getName(id);\n\n            options.onComplete(id, name, response, optXhr);\n\n            if (handler._getFileState(id)) {\n                handler._clearXhrs && handler._clearXhrs(id);\n            }\n\n            connectionManager.free(id);\n        },\n\n        // Returns a qq.BlobProxy, or an actual File/Blob if no proxy is involved, or undefined\n        // if none of these are available for the ID\n        getProxyOrBlob: function(id) {\n            return (handler.getProxy && handler.getProxy(id)) ||\n                (handler.getFile && handler.getFile(id));\n        },\n\n        initHandler: function() {\n            var handlerType = namespace ? qq[namespace] : qq.traditional,\n                handlerModuleSubtype = qq.supportedFeatures.ajaxUploading ? \"Xhr\" : \"Form\";\n\n            handler = new handlerType[handlerModuleSubtype + \"UploadHandler\"](\n                options,\n                {\n                    getCustomResumeData: options.getCustomResumeData,\n                    getDataByUuid: options.getDataByUuid,\n                    getName: options.getName,\n                    getSize: options.getSize,\n                    getUuid: options.getUuid,\n                    log: log,\n                    onCancel: options.onCancel,\n                    onProgress: options.onProgress,\n                    onUuidChanged: options.onUuidChanged,\n                    onFinalizing: function(id) {\n                        options.setStatus(id, qq.status.UPLOAD_FINALIZING);\n                    }\n                }\n            );\n\n            if (handler._removeExpiredChunkingRecords) {\n                handler._removeExpiredChunkingRecords();\n            }\n        },\n\n        isDeferredEligibleForUpload: function(id) {\n            return options.isQueued(id);\n        },\n\n        // For Blobs that are part of a group of generated images, along with a reference image,\n        // this will ensure the blobs in the group are uploaded in the order they were triggered,\n        // even if some async processing must be completed on one or more Blobs first.\n        maybeDefer: function(id, blob) {\n            // If we don't have a file/blob yet & no file/blob exists for this item, request it,\n            // and then submit the upload to the specific handler once the blob is available.\n            // ASSUMPTION: This condition will only ever be true if XHR uploading is supported.\n            if (blob && !handler.getFile(id) && blob instanceof qq.BlobProxy) {\n\n                // Blob creation may take some time, so the caller may want to update the\n                // UI to indicate that an operation is in progress, even before the actual\n                // upload begins and an onUpload callback is invoked.\n                options.onUploadPrep(id);\n\n                log(\"Attempting to generate a blob on-demand for \" + id);\n                blob.create().then(function(generatedBlob) {\n                    log(\"Generated an on-demand blob for \" + id);\n\n                    // Update record associated with this file by providing the generated Blob\n                    handler.updateBlob(id, generatedBlob);\n\n                    // Propagate the size for this generated Blob\n                    options.setSize(id, generatedBlob.size);\n\n                    // Order handler to recalculate chunking possibility, if applicable\n                    handler.reevaluateChunking(id);\n\n                    upload.maybeSendDeferredFiles(id);\n                },\n\n                // Blob could not be generated.  Fail the upload & attempt to prevent retries.  Also bubble error message.\n                function(errorMessage) {\n                    var errorResponse = {};\n\n                    if (errorMessage) {\n                        errorResponse.error = errorMessage;\n                    }\n\n                    log(qq.format(\"Failed to generate blob for ID {}.  Error message: {}.\", id, errorMessage), \"error\");\n\n                    options.onComplete(id, options.getName(id), qq.extend(errorResponse, preventRetryResponse), null);\n                    upload.maybeSendDeferredFiles(id);\n                    connectionManager.free(id);\n                });\n            }\n            else {\n                return upload.maybeSendDeferredFiles(id);\n            }\n\n            return false;\n        },\n\n        // Upload any grouped blobs, in the proper order, that are ready to be uploaded\n        maybeSendDeferredFiles: function(id) {\n            var idsInGroup = options.getIdsInProxyGroup(id),\n                uploadedThisId = false;\n\n            if (idsInGroup && idsInGroup.length) {\n                log(\"Maybe ready to upload proxy group file \" + id);\n\n                qq.each(idsInGroup, function(idx, idInGroup) {\n                    if (upload.isDeferredEligibleForUpload(idInGroup) && !!handler.getFile(idInGroup)) {\n                        uploadedThisId = idInGroup === id;\n                        upload.now(idInGroup);\n                    }\n                    else if (upload.isDeferredEligibleForUpload(idInGroup)) {\n                        return false;\n                    }\n                });\n            }\n            else {\n                uploadedThisId = true;\n                upload.now(id);\n            }\n\n            return uploadedThisId;\n        },\n\n        maybeNewUuid: function(id, response) {\n            if (response.newUuid !== undefined) {\n                options.onUuidChanged(id, response.newUuid);\n            }\n        },\n\n        // The response coming from handler implementations may be in various formats.\n        // Instead of hoping a promise nested 5 levels deep will always return an object\n        // as its first param, let's just normalize the response here.\n        normalizeResponse: function(originalResponse, successful) {\n            var response = originalResponse;\n\n            // The passed \"response\" param may not be a response at all.\n            // It could be a string, detailing the error, for example.\n            if (!qq.isObject(originalResponse)) {\n                response = {};\n\n                if (qq.isString(originalResponse) && !successful) {\n                    response.error = originalResponse;\n                }\n            }\n\n            response.success = successful;\n\n            return response;\n        },\n\n        now: function(id) {\n            var name = options.getName(id);\n\n            if (!controller.isValid(id)) {\n                throw new qq.Error(id + \" is not a valid file ID to upload!\");\n            }\n\n            options.onUpload(id, name).then(\n                function(response) {\n                    if (response && response.pause) {\n                        options.setStatus(id, qq.status.PAUSED);\n                        handler.pause(id);\n                        connectionManager.free(id);\n                    }\n                    else {\n                        if (chunkingPossible && handler._shouldChunkThisFile(id)) {\n                            chunked.sendNext(id);\n                        }\n                        else {\n                            simple.send(id, name);\n                        }\n                    }\n                },\n\n                function(error) {\n                    error = error || {};\n\n                    log(id + \" upload start aborted due to rejected onUpload Promise - details: \" + error, \"error\");\n\n                    if (!options.onAutoRetry(id, name, error.responseJSON || {})) {\n                        var response = upload.normalizeResponse(error.responseJSON, false);\n                        upload.cleanup(id, response);\n                    }\n                }\n            );\n        },\n\n        start: function(id) {\n            var blobToUpload = upload.getProxyOrBlob(id);\n\n            if (blobToUpload) {\n                return upload.maybeDefer(id, blobToUpload);\n            }\n            else {\n                upload.now(id);\n                return true;\n            }\n        }\n    };\n\n    qq.extend(this, {\n        /**\n         * Adds file or file input to the queue\n         **/\n        add: function(id, file) {\n            handler.add.apply(this, arguments);\n        },\n\n        /**\n         * Sends the file identified by id\n         */\n        upload: function(id) {\n            if (connectionManager.open(id)) {\n                return upload.start(id);\n            }\n            return false;\n        },\n\n        retry: function(id) {\n            // On retry, if concurrent chunking has been enabled, we may have aborted all other in-progress chunks\n            // for a file when encountering a failed chunk upload.  We then signaled the controller to ignore\n            // all failures associated with these aborts.  We are now retrying, so we don't want to ignore\n            // any more failures at this point.\n            if (concurrentChunkingPossible) {\n                handler._getFileState(id).temp.ignoreFailure = false;\n            }\n\n            // If we are attempting to retry a file that is already consuming a connection, this is likely an auto-retry.\n            // Just go ahead and ask the handler to upload again.\n            if (connectionManager.isUsingConnection(id)) {\n                return upload.start(id);\n            }\n\n            // If we are attempting to retry a file that is not currently consuming a connection,\n            // this is likely a manual retry attempt.  We will need to ensure a connection is available\n            // before the retry commences.\n            else {\n                return controller.upload(id);\n            }\n        },\n\n        /**\n         * Cancels file upload by id\n         */\n        cancel: function(id) {\n            var cancelRetVal = handler.cancel(id);\n\n            if (qq.isGenericPromise(cancelRetVal)) {\n                cancelRetVal.then(function() {\n                    upload.cancel(id);\n                });\n            }\n            else if (cancelRetVal !== false) {\n                upload.cancel(id);\n            }\n        },\n\n        /**\n         * Cancels all queued or in-progress uploads\n         */\n        cancelAll: function() {\n            var waitingOrConnected = connectionManager.getWaitingOrConnected(),\n                i;\n\n            // ensure files are cancelled in reverse order which they were added\n            // to avoid a flash of time where a queued file begins to upload before it is canceled\n            if (waitingOrConnected.length) {\n                for (i = waitingOrConnected.length - 1; i >= 0; i--) {\n                    controller.cancel(waitingOrConnected[i]);\n                }\n            }\n\n            connectionManager.reset();\n        },\n\n        // Returns a File, Blob, or the Blob/File for the reference/parent file if the targeted blob is a proxy.\n        // Undefined if no file record is available.\n        getFile: function(id) {\n            if (handler.getProxy && handler.getProxy(id)) {\n                return handler.getProxy(id).referenceBlob;\n            }\n\n            return handler.getFile && handler.getFile(id);\n        },\n\n        // Returns true if the Blob associated with the ID is related to a proxy s\n        isProxied: function(id) {\n            return !!(handler.getProxy && handler.getProxy(id));\n        },\n\n        getInput: function(id) {\n            if (handler.getInput) {\n                return handler.getInput(id);\n            }\n        },\n\n        reset: function() {\n            log(\"Resetting upload handler\");\n            controller.cancelAll();\n            connectionManager.reset();\n            handler.reset();\n        },\n\n        expunge: function(id) {\n            if (controller.isValid(id)) {\n                return handler.expunge(id);\n            }\n        },\n\n        /**\n         * Determine if the file exists.\n         */\n        isValid: function(id) {\n            return handler.isValid(id);\n        },\n\n        hasResumeRecord: function(id) {\n            var key = handler.isValid(id) &&\n                handler._getLocalStorageId &&\n                handler._getLocalStorageId(id);\n\n            if (key) {\n                return !!localStorage.getItem(key);\n            }\n\n            return false;\n        },\n\n        getResumableFilesData: function() {\n            if (handler.getResumableFilesData) {\n                return handler.getResumableFilesData();\n            }\n            return [];\n        },\n\n        /**\n         * This may or may not be implemented, depending on the handler.  For handlers where a third-party ID is\n         * available (such as the \"key\" for Amazon S3), this will return that value.  Otherwise, the return value\n         * will be undefined.\n         *\n         * @param id Internal file ID\n         * @returns {*} Some identifier used by a 3rd-party service involved in the upload process\n         */\n        getThirdPartyFileId: function(id) {\n            if (controller.isValid(id)) {\n                return handler.getThirdPartyFileId(id);\n            }\n        },\n\n        /**\n         * Attempts to pause the associated upload if the specific handler supports this and the file is \"valid\".\n         * @param id ID of the upload/file to pause\n         * @returns {boolean} true if the upload was paused\n         */\n        pause: function(id) {\n            if (controller.isResumable(id) && handler.pause && controller.isValid(id) && handler.pause(id)) {\n                connectionManager.free(id);\n                handler.moveInProgressToRemaining(id);\n                return true;\n            }\n            return false;\n        },\n\n        isAttemptingResume: function(id) {\n            return !!handler.isAttemptingResume && handler.isAttemptingResume(id);\n        },\n\n        // True if the file is eligible for pause/resume.\n        isResumable: function(id) {\n            return !!handler.isResumable && handler.isResumable(id);\n        }\n    });\n\n    qq.extend(options, o);\n    log = options.log;\n    chunkingPossible = options.chunking.enabled && qq.supportedFeatures.chunking;\n    concurrentChunkingPossible = chunkingPossible && options.chunking.concurrent.enabled;\n\n    preventRetryResponse = (function() {\n        var response = {};\n\n        response[options.preventRetryParam] = true;\n\n        return response;\n    }());\n\n    upload.initHandler();\n};\n","/*globals qq */\n/*jshint -W117 */\nqq.WindowReceiveMessage = function(o) {\n    \"use strict\";\n\n    var options = {\n            log: function(message, level) {}\n        },\n        callbackWrapperDetachers = {};\n\n    qq.extend(options, o);\n\n    qq.extend(this, {\n        receiveMessage: function(id, callback) {\n            var onMessageCallbackWrapper = function(event) {\n                    callback(event.data);\n                };\n\n            if (window.postMessage) {\n                callbackWrapperDetachers[id] = qq(window).attach(\"message\", onMessageCallbackWrapper);\n            }\n            else {\n                log(\"iframe message passing not supported in this browser!\", \"error\");\n            }\n        },\n\n        stopReceivingMessages: function(id) {\n            if (window.postMessage) {\n                var detacher = callbackWrapperDetachers[id];\n                if (detacher) {\n                    detacher();\n                }\n            }\n        }\n    });\n};\n","/* globals qq */\n/**\n * Common APIs exposed to creators of upload via form/iframe handlers.  This is reused and possibly overridden\n * in some cases by specific form upload handlers.\n *\n * @constructor\n */\nqq.FormUploadHandler = function(spec) {\n    \"use strict\";\n\n    var options = spec.options,\n        handler = this,\n        proxy = spec.proxy,\n        formHandlerInstanceId = qq.getUniqueId(),\n        onloadCallbacks = {},\n        detachLoadEvents = {},\n        postMessageCallbackTimers = {},\n        isCors = options.isCors,\n        inputName = options.inputName,\n        getUuid = proxy.getUuid,\n        log = proxy.log,\n        corsMessageReceiver = new qq.WindowReceiveMessage({log: log});\n\n    /**\n     * Remove any trace of the file from the handler.\n     *\n     * @param id ID of the associated file\n     */\n    function expungeFile(id) {\n        delete detachLoadEvents[id];\n\n        // If we are dealing with CORS, we might still be waiting for a response from a loaded iframe.\n        // In that case, terminate the timer waiting for a message from the loaded iframe\n        // and stop listening for any more messages coming from this iframe.\n        if (isCors) {\n            clearTimeout(postMessageCallbackTimers[id]);\n            delete postMessageCallbackTimers[id];\n            corsMessageReceiver.stopReceivingMessages(id);\n        }\n\n        var iframe = document.getElementById(handler._getIframeName(id));\n        if (iframe) {\n            // To cancel request set src to something else.  We use src=\"javascript:false;\"\n            // because it doesn't trigger ie6 prompt on https\n            /* jshint scripturl:true */\n            iframe.setAttribute(\"src\", \"javascript:false;\");\n\n            qq(iframe).remove();\n        }\n    }\n\n    /**\n     * @param iframeName `document`-unique Name of the associated iframe\n     * @returns {*} ID of the associated file\n     */\n    function getFileIdForIframeName(iframeName) {\n        return iframeName.split(\"_\")[0];\n    }\n\n    /**\n     * Generates an iframe to be used as a target for upload-related form submits.  This also adds the iframe\n     * to the current `document`.  Note that the iframe is hidden from view.\n     *\n     * @param name Name of the iframe.\n     * @returns {HTMLIFrameElement} The created iframe\n     */\n    function initIframeForUpload(name) {\n        var iframe = qq.toElement(\"<iframe src='javascript:false;' name='\" + name + \"' />\");\n\n        iframe.setAttribute(\"id\", name);\n\n        iframe.style.display = \"none\";\n        document.body.appendChild(iframe);\n\n        return iframe;\n    }\n\n    /**\n     * If we are in CORS mode, we must listen for messages (containing the server response) from the associated\n     * iframe, since we cannot directly parse the content of the iframe due to cross-origin restrictions.\n     *\n     * @param iframe Listen for messages on this iframe.\n     * @param callback Invoke this callback with the message from the iframe.\n     */\n    function registerPostMessageCallback(iframe, callback) {\n        var iframeName = iframe.id,\n            fileId = getFileIdForIframeName(iframeName),\n            uuid = getUuid(fileId);\n\n        onloadCallbacks[uuid] = callback;\n\n        // When the iframe has loaded (after the server responds to an upload request)\n        // declare the attempt a failure if we don't receive a valid message shortly after the response comes in.\n        detachLoadEvents[fileId] = qq(iframe).attach(\"load\", function() {\n            if (handler.getInput(fileId)) {\n                log(\"Received iframe load event for CORS upload request (iframe name \" + iframeName + \")\");\n\n                postMessageCallbackTimers[iframeName] = setTimeout(function() {\n                    var errorMessage = \"No valid message received from loaded iframe for iframe name \" + iframeName;\n                    log(errorMessage, \"error\");\n                    callback({\n                        error: errorMessage\n                    });\n                }, 1000);\n            }\n        });\n\n        // Listen for messages coming from this iframe.  When a message has been received, cancel the timer\n        // that declares the upload a failure if a message is not received within a reasonable amount of time.\n        corsMessageReceiver.receiveMessage(iframeName, function(message) {\n            log(\"Received the following window message: '\" + message + \"'\");\n            var fileId = getFileIdForIframeName(iframeName),\n                response = handler._parseJsonResponse(message),\n                uuid = response.uuid,\n                onloadCallback;\n\n            if (uuid && onloadCallbacks[uuid]) {\n                log(\"Handling response for iframe name \" + iframeName);\n                clearTimeout(postMessageCallbackTimers[iframeName]);\n                delete postMessageCallbackTimers[iframeName];\n\n                handler._detachLoadEvent(iframeName);\n\n                onloadCallback = onloadCallbacks[uuid];\n\n                delete onloadCallbacks[uuid];\n                corsMessageReceiver.stopReceivingMessages(iframeName);\n                onloadCallback(response);\n            }\n            else if (!uuid) {\n                log(\"'\" + message + \"' does not contain a UUID - ignoring.\");\n            }\n        });\n    }\n\n    qq.extend(this, new qq.UploadHandler(spec));\n\n    qq.override(this, function(super_) {\n        return {\n            /**\n             * Adds File or Blob to the queue\n             **/\n            add: function(id, fileInput) {\n                super_.add(id, {input: fileInput});\n\n                fileInput.setAttribute(\"name\", inputName);\n\n                // remove file input from DOM\n                if (fileInput.parentNode) {\n                    qq(fileInput).remove();\n                }\n            },\n\n            expunge: function(id) {\n                expungeFile(id);\n                super_.expunge(id);\n            },\n\n            isValid: function(id) {\n                return super_.isValid(id) &&\n                    handler._getFileState(id).input !== undefined;\n            }\n        };\n    });\n\n    qq.extend(this, {\n        getInput: function(id) {\n            return handler._getFileState(id).input;\n        },\n\n        /**\n         * This function either delegates to a more specific message handler if CORS is involved,\n         * or simply registers a callback when the iframe has been loaded that invokes the passed callback\n         * after determining if the content of the iframe is accessible.\n         *\n         * @param iframe Associated iframe\n         * @param callback Callback to invoke after we have determined if the iframe content is accessible.\n         */\n        _attachLoadEvent: function(iframe, callback) {\n            /*jslint eqeq: true*/\n            var responseDescriptor;\n\n            if (isCors) {\n                registerPostMessageCallback(iframe, callback);\n            }\n            else {\n                detachLoadEvents[iframe.id] = qq(iframe).attach(\"load\", function() {\n                    log(\"Received response for \" + iframe.id);\n\n                    // when we remove iframe from dom\n                    // the request stops, but in IE load\n                    // event fires\n                    if (!iframe.parentNode) {\n                        return;\n                    }\n\n                    try {\n                        // fixing Opera 10.53\n                        if (iframe.contentDocument &&\n                            iframe.contentDocument.body &&\n                            iframe.contentDocument.body.innerHTML == \"false\") {\n                            // In Opera event is fired second time\n                            // when body.innerHTML changed from false\n                            // to server response approx. after 1 sec\n                            // when we upload file with iframe\n                            return;\n                        }\n                    }\n                    catch (error) {\n                        //IE may throw an \"access is denied\" error when attempting to access contentDocument on the iframe in some cases\n                        log(\"Error when attempting to access iframe during handling of upload response (\" + error.message + \")\", \"error\");\n                        responseDescriptor = {success: false};\n                    }\n\n                    callback(responseDescriptor);\n                });\n            }\n        },\n\n        /**\n         * Creates an iframe with a specific document-unique name.\n         *\n         * @param id ID of the associated file\n         * @returns {HTMLIFrameElement}\n         */\n        _createIframe: function(id) {\n            var iframeName = handler._getIframeName(id);\n\n            return initIframeForUpload(iframeName);\n        },\n\n        /**\n         * Called when we are no longer interested in being notified when an iframe has loaded.\n         *\n         * @param id Associated file ID\n         */\n        _detachLoadEvent: function(id) {\n            if (detachLoadEvents[id] !== undefined) {\n                detachLoadEvents[id]();\n                delete detachLoadEvents[id];\n            }\n        },\n\n        /**\n         * @param fileId ID of the associated file\n         * @returns {string} The `document`-unique name of the iframe\n         */\n        _getIframeName: function(fileId) {\n            return fileId + \"_\" + formHandlerInstanceId;\n        },\n\n        /**\n         * Generates a form element and appends it to the `document`.  When the form is submitted, a specific iframe is targeted.\n         * The name of the iframe is passed in as a property of the spec parameter, and must be unique in the `document`.  Note\n         * that the form is hidden from view.\n         *\n         * @param spec An object containing various properties to be used when constructing the form.  Required properties are\n         * currently: `method`, `endpoint`, `params`, `paramsInBody`, and `targetName`.\n         * @returns {HTMLFormElement} The created form\n         */\n        _initFormForUpload: function(spec) {\n            var method = spec.method,\n                endpoint = spec.endpoint,\n                params = spec.params,\n                paramsInBody = spec.paramsInBody,\n                targetName = spec.targetName,\n                form = qq.toElement(\"<form method='\" + method + \"' enctype='multipart/form-data'></form>\"),\n                url = endpoint;\n\n            if (paramsInBody) {\n                qq.obj2Inputs(params, form);\n            }\n            else {\n                url = qq.obj2url(params, endpoint);\n            }\n\n            form.setAttribute(\"action\", url);\n            form.setAttribute(\"target\", targetName);\n            form.style.display = \"none\";\n            document.body.appendChild(form);\n\n            return form;\n        },\n\n        /**\n         * @param innerHtmlOrMessage JSON message\n         * @returns {*} The parsed response, or an empty object if the response could not be parsed\n         */\n        _parseJsonResponse: function(innerHtmlOrMessage) {\n            var response = {};\n\n            try {\n                response = qq.parseJson(innerHtmlOrMessage);\n            }\n            catch (error) {\n                log(\"Error when attempting to parse iframe upload response (\" + error.message + \")\", \"error\");\n            }\n\n            return response;\n        }\n    });\n};\n","/* globals qq */\n/**\n * Common API exposed to creators of XHR handlers.  This is reused and possibly overriding in some cases by specific\n * XHR upload handlers.\n *\n * @constructor\n */\nqq.XhrUploadHandler = function(spec) {\n    \"use strict\";\n\n    var handler = this,\n        namespace = spec.options.namespace,\n        proxy = spec.proxy,\n        chunking = spec.options.chunking,\n        getChunkSize = function(id) {\n            var fileState = handler._getFileState(id);\n\n            if (fileState.chunkSize) {\n                return fileState.chunkSize;\n            }\n\n            else {\n                var chunkSize = chunking.partSize;\n\n                if (qq.isFunction(chunkSize)) {\n                    chunkSize = chunkSize(id, getSize(id));\n                }\n\n                fileState.chunkSize = chunkSize;\n                return chunkSize;\n            }\n        },\n        resume = spec.options.resume,\n        chunkFiles = chunking && spec.options.chunking.enabled && qq.supportedFeatures.chunking,\n        resumeEnabled = resume && spec.options.resume.enabled && chunkFiles && qq.supportedFeatures.resume,\n        getName = proxy.getName,\n        getSize = proxy.getSize,\n        getUuid = proxy.getUuid,\n        getEndpoint = proxy.getEndpoint,\n        getDataByUuid = proxy.getDataByUuid,\n        onUuidChanged = proxy.onUuidChanged,\n        onProgress = proxy.onProgress,\n        log = proxy.log,\n        getCustomResumeData = proxy.getCustomResumeData;\n\n    function abort(id) {\n        qq.each(handler._getXhrs(id), function(xhrId, xhr) {\n            var ajaxRequester = handler._getAjaxRequester(id, xhrId);\n\n            xhr.onreadystatechange = null;\n            xhr.upload.onprogress = null;\n            xhr.abort();\n            ajaxRequester && ajaxRequester.canceled && ajaxRequester.canceled(id);\n        });\n    }\n\n    qq.extend(this, new qq.UploadHandler(spec));\n\n    qq.override(this, function(super_) {\n        return {\n            /**\n             * Adds File or Blob to the queue\n             **/\n            add: function(id, blobOrProxy) {\n                if (qq.isFile(blobOrProxy) || qq.isBlob(blobOrProxy)) {\n                    super_.add(id, {file: blobOrProxy});\n                }\n                else if (blobOrProxy instanceof qq.BlobProxy) {\n                    super_.add(id, {proxy: blobOrProxy});\n                }\n                else {\n                    throw new Error(\"Passed obj is not a File, Blob, or proxy\");\n                }\n\n                handler._initTempState(id);\n                resumeEnabled && handler._maybePrepareForResume(id);\n            },\n\n            expunge: function(id) {\n                abort(id);\n                handler._maybeDeletePersistedChunkData(id);\n                handler._clearXhrs(id);\n                super_.expunge(id);\n            }\n        };\n    });\n\n    qq.extend(this, {\n        // Clear the cached chunk `Blob` after we are done with it, just in case the `Blob` bytes are stored in memory.\n        clearCachedChunk: function(id, chunkIdx) {\n            var fileState = handler._getFileState(id);\n\n            if (fileState) {\n                delete fileState.temp.cachedChunks[chunkIdx];\n            }\n        },\n\n        clearXhr: function(id, chunkIdx) {\n            var tempState = handler._getFileState(id).temp;\n\n            if (tempState.xhrs) {\n                delete tempState.xhrs[chunkIdx];\n            }\n            if (tempState.ajaxRequesters) {\n                delete tempState.ajaxRequesters[chunkIdx];\n            }\n        },\n\n        // Called when all chunks have been successfully uploaded.  Expected promissory return type.\n        // This defines the default behavior if nothing further is required when all chunks have been uploaded.\n        finalizeChunks: function(id, responseParser) {\n            var lastChunkIdx = handler._getTotalChunks(id) - 1,\n                xhr = handler._getXhr(id, lastChunkIdx);\n\n            if (responseParser) {\n                return new qq.Promise().success(responseParser(xhr), xhr);\n            }\n\n            return new qq.Promise().success({}, xhr);\n        },\n\n        getFile: function(id) {\n            return handler.isValid(id) && handler._getFileState(id).file;\n        },\n\n        getProxy: function(id) {\n            return handler.isValid(id) && handler._getFileState(id).proxy;\n        },\n\n        /**\n         * @returns {Array} Array of objects containing properties useful to integrators\n         * when it is important to determine which files are potentially resumable.\n         */\n        getResumableFilesData: function() {\n            var resumableFilesData = [];\n\n            handler._iterateResumeRecords(function(key, uploadData) {\n                handler.moveInProgressToRemaining(null, uploadData.chunking.inProgress,  uploadData.chunking.remaining);\n\n                var data = {\n                    name: uploadData.name,\n                    remaining: uploadData.chunking.remaining,\n                    size: uploadData.size,\n                    uuid: uploadData.uuid\n                };\n\n                if (uploadData.key) {\n                    data.key = uploadData.key;\n                }\n\n                if (uploadData.customResumeData) {\n                    data.customResumeData = uploadData.customResumeData;\n                }\n\n                resumableFilesData.push(data);\n            });\n\n            return resumableFilesData;\n        },\n\n        isAttemptingResume: function(id) {\n            return handler._getFileState(id).attemptingResume;\n        },\n\n        isResumable: function(id) {\n            return !!chunking && handler.isValid(id) &&\n                !handler._getFileState(id).notResumable;\n        },\n\n        moveInProgressToRemaining: function(id, optInProgress, optRemaining) {\n            var fileState = handler._getFileState(id) || {},\n                chunkingState =  fileState.chunking || {},\n                inProgress = optInProgress || chunkingState.inProgress,\n                remaining = optRemaining || chunkingState.remaining;\n\n            if (inProgress) {\n                log(qq.format(\"Moving these chunks from in-progress {}, to remaining.\", JSON.stringify(inProgress)));\n                inProgress.reverse();\n                qq.each(inProgress, function(idx, chunkIdx) {\n                    remaining.unshift(chunkIdx);\n                });\n                inProgress.length = 0;\n            }\n        },\n\n        pause: function(id) {\n            if (handler.isValid(id)) {\n                log(qq.format(\"Aborting XHR upload for {} '{}' due to pause instruction.\", id, getName(id)));\n                handler._getFileState(id).paused = true;\n                abort(id);\n                return true;\n            }\n        },\n\n        reevaluateChunking: function(id) {\n            if (chunking && handler.isValid(id)) {\n                var state = handler._getFileState(id),\n                    totalChunks,\n                    i;\n\n                delete state.chunking;\n\n                state.chunking = {};\n                totalChunks = handler._getTotalChunks(id);\n                if (totalChunks > 1 || chunking.mandatory) {\n                    state.chunking.enabled = true;\n                    state.chunking.parts = totalChunks;\n                    state.chunking.remaining = [];\n\n                    for (i = 0; i < totalChunks; i++) {\n                        state.chunking.remaining.push(i);\n                    }\n\n                    handler._initTempState(id);\n                }\n                else {\n                    state.chunking.enabled = false;\n                }\n            }\n        },\n\n        updateBlob: function(id, newBlob) {\n            if (handler.isValid(id)) {\n                handler._getFileState(id).file = newBlob;\n            }\n        },\n\n        _clearXhrs: function(id) {\n            var tempState = handler._getFileState(id).temp;\n\n            qq.each(tempState.ajaxRequesters, function(chunkId) {\n                delete tempState.ajaxRequesters[chunkId];\n            });\n\n            qq.each(tempState.xhrs, function(chunkId) {\n                delete tempState.xhrs[chunkId];\n            });\n        },\n\n        /**\n         * Creates an XHR instance for this file and stores it in the fileState.\n         *\n         * @param id File ID\n         * @param optChunkIdx The chunk index associated with this XHR, if applicable\n         * @returns {XMLHttpRequest}\n         */\n        _createXhr: function(id, optChunkIdx) {\n            return handler._registerXhr(id, optChunkIdx, qq.createXhrInstance());\n        },\n\n        _getAjaxRequester: function(id, optChunkIdx) {\n            var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;\n            return handler._getFileState(id).temp.ajaxRequesters[chunkIdx];\n        },\n\n        _getChunkData: function(id, chunkIndex) {\n            var chunkSize = getChunkSize(id),\n                fileSize = getSize(id),\n                fileOrBlob = handler.getFile(id),\n                startBytes = chunkSize * chunkIndex,\n                endBytes = startBytes + chunkSize >= fileSize ? fileSize : startBytes + chunkSize,\n                totalChunks = handler._getTotalChunks(id),\n                cachedChunks = this._getFileState(id).temp.cachedChunks,\n\n            // To work around a Webkit GC bug, we must keep each chunk `Blob` in scope until we are done with it.\n            // See https://github.com/FineUploader/fine-uploader/issues/937#issuecomment-41418760\n                blob = cachedChunks[chunkIndex] || qq.sliceBlob(fileOrBlob, startBytes, endBytes);\n\n            cachedChunks[chunkIndex] = blob;\n\n            return {\n                part: chunkIndex,\n                start: startBytes,\n                end: endBytes,\n                count: totalChunks,\n                blob: blob,\n                size: endBytes - startBytes\n            };\n        },\n\n        _getChunkDataForCallback: function(chunkData) {\n            return {\n                partIndex: chunkData.part,\n                startByte: chunkData.start + 1,\n                endByte: chunkData.end,\n                totalParts: chunkData.count\n            };\n        },\n\n        /**\n         * @param id File ID\n         * @returns {string} Identifier for this item that may appear in the browser's local storage\n         */\n        _getLocalStorageId: function(id) {\n            var formatVersion = \"5.0\",\n                name = getName(id),\n                size = getSize(id),\n                chunkSize = getChunkSize(id),\n                endpoint = getEndpoint(id),\n                customKeys = resume.customKeys(id),\n                localStorageId = qq.format(\"qq{}resume{}-{}-{}-{}-{}\", namespace, formatVersion, name, size, chunkSize, endpoint);\n\n            customKeys.forEach(function(key) {\n                localStorageId += \"-\" + key;\n            });\n\n            return localStorageId;\n        },\n\n        _getMimeType: function(id) {\n            return handler.getFile(id).type;\n        },\n\n        _getPersistableData: function(id) {\n            return handler._getFileState(id).chunking;\n        },\n\n        /**\n         * @param id ID of the associated file\n         * @returns {number} Number of parts this file can be divided into, or undefined if chunking is not supported in this UA\n         */\n        _getTotalChunks: function(id) {\n            if (chunking) {\n                var fileSize = getSize(id),\n                    chunkSize = getChunkSize(id);\n\n                return Math.ceil(fileSize / chunkSize);\n            }\n        },\n\n        _getXhr: function(id, optChunkIdx) {\n            var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;\n            return handler._getFileState(id).temp.xhrs[chunkIdx];\n        },\n\n        _getXhrs: function(id) {\n            return handler._getFileState(id).temp.xhrs;\n        },\n\n        // Iterates through all XHR handler-created resume records (in local storage),\n        // invoking the passed callback and passing in the key and value of each local storage record.\n        _iterateResumeRecords: function(callback) {\n            if (resumeEnabled) {\n                qq.each(localStorage, function(key, item) {\n                    if (key.indexOf(qq.format(\"qq{}resume\", namespace)) === 0) {\n                        var uploadData = JSON.parse(item);\n                        callback(key, uploadData);\n                    }\n                });\n            }\n        },\n\n        _initTempState: function(id) {\n            handler._getFileState(id).temp = {\n                ajaxRequesters: {},\n                chunkProgress: {},\n                xhrs: {},\n                cachedChunks: {}\n            };\n        },\n\n        _markNotResumable: function(id) {\n            handler._getFileState(id).notResumable = true;\n        },\n\n        // Removes a chunked upload record from local storage, if possible.\n        // Returns true if the item was removed, false otherwise.\n        _maybeDeletePersistedChunkData: function(id) {\n            var localStorageId;\n\n            if (resumeEnabled && handler.isResumable(id)) {\n                localStorageId = handler._getLocalStorageId(id);\n\n                if (localStorageId && localStorage.getItem(localStorageId)) {\n                    localStorage.removeItem(localStorageId);\n                    return true;\n                }\n            }\n\n            return false;\n        },\n\n        // If this is a resumable upload, grab the relevant data from storage and items in memory that track this upload\n        // so we can pick up from where we left off.\n        _maybePrepareForResume: function(id) {\n            var state = handler._getFileState(id),\n                localStorageId, persistedData;\n\n            // Resume is enabled and possible and this is the first time we've tried to upload this file in this session,\n            // so prepare for a resume attempt.\n            if (resumeEnabled && state.key === undefined) {\n                localStorageId = handler._getLocalStorageId(id);\n                persistedData = localStorage.getItem(localStorageId);\n\n                // If we found this item in local storage, maybe we should resume it.\n                if (persistedData) {\n                    persistedData = JSON.parse(persistedData);\n\n                    // If we found a resume record but we have already handled this file in this session,\n                    // don't try to resume it & ensure we don't persist future check data\n                    if (getDataByUuid(persistedData.uuid)) {\n                        handler._markNotResumable(id);\n                    }\n                    else {\n                        log(qq.format(\"Identified file with ID {} and name of {} as resumable.\", id, getName(id)));\n\n                        onUuidChanged(id, persistedData.uuid);\n\n                        state.key = persistedData.key;\n                        state.chunking = persistedData.chunking;\n                        state.loaded = persistedData.loaded;\n                        state.customResumeData = persistedData.customResumeData;\n                        state.attemptingResume = true;\n\n                        handler.moveInProgressToRemaining(id);\n                    }\n                }\n            }\n        },\n\n        // Persist any data needed to resume this upload in a new session.\n        _maybePersistChunkedState: function(id) {\n            var state = handler._getFileState(id),\n                localStorageId, persistedData;\n\n            // If local storage isn't supported by the browser, or if resume isn't enabled or possible, give up\n            if (resumeEnabled && handler.isResumable(id)) {\n                var customResumeData = getCustomResumeData(id);\n\n                localStorageId = handler._getLocalStorageId(id);\n\n                persistedData = {\n                    name: getName(id),\n                    size: getSize(id),\n                    uuid: getUuid(id),\n                    key: state.key,\n                    chunking: state.chunking,\n                    loaded: state.loaded,\n                    lastUpdated: Date.now(),\n                };\n\n                if (customResumeData) {\n                    persistedData.customResumeData = customResumeData;\n                }\n\n                try {\n                    localStorage.setItem(localStorageId, JSON.stringify(persistedData));\n                }\n                catch (error) {\n                    log(qq.format(\"Unable to save resume data for '{}' due to error: '{}'.\", id, error.toString()), \"warn\");\n                }\n            }\n        },\n\n        _registerProgressHandler: function(id, chunkIdx, chunkSize) {\n            var xhr = handler._getXhr(id, chunkIdx),\n                name = getName(id),\n                progressCalculator = {\n                    simple: function(loaded, total) {\n                        var fileSize = getSize(id);\n\n                        if (loaded === total) {\n                            onProgress(id, name, fileSize, fileSize);\n                        }\n                        else {\n                            onProgress(id, name, (loaded >= fileSize ? fileSize - 1 : loaded), fileSize);\n                        }\n                    },\n\n                    chunked: function(loaded, total) {\n                        var chunkProgress = handler._getFileState(id).temp.chunkProgress,\n                            totalSuccessfullyLoadedForFile = handler._getFileState(id).loaded,\n                            loadedForRequest = loaded,\n                            totalForRequest = total,\n                            totalFileSize = getSize(id),\n                            estActualChunkLoaded = loadedForRequest - (totalForRequest - chunkSize),\n                            totalLoadedForFile = totalSuccessfullyLoadedForFile;\n\n                        chunkProgress[chunkIdx] = estActualChunkLoaded;\n\n                        qq.each(chunkProgress, function(chunkIdx, chunkLoaded) {\n                            totalLoadedForFile += chunkLoaded;\n                        });\n\n                        onProgress(id, name, totalLoadedForFile, totalFileSize);\n                    }\n                };\n\n            xhr.upload.onprogress = function(e) {\n                if (e.lengthComputable) {\n                    /* jshint eqnull: true */\n                    var type = chunkSize == null ? \"simple\" : \"chunked\";\n                    progressCalculator[type](e.loaded, e.total);\n                }\n            };\n        },\n\n        /**\n         * Registers an XHR transport instance created elsewhere.\n         *\n         * @param id ID of the associated file\n         * @param optChunkIdx The chunk index associated with this XHR, if applicable\n         * @param xhr XMLHttpRequest object instance\n         * @param optAjaxRequester `qq.AjaxRequester` associated with this request, if applicable.\n         * @returns {XMLHttpRequest}\n         */\n        _registerXhr: function(id, optChunkIdx, xhr, optAjaxRequester) {\n            var xhrsId = optChunkIdx == null ? -1 : optChunkIdx,\n                tempState = handler._getFileState(id).temp;\n\n            tempState.xhrs = tempState.xhrs || {};\n            tempState.ajaxRequesters = tempState.ajaxRequesters || {};\n\n            tempState.xhrs[xhrsId] = xhr;\n\n            if (optAjaxRequester) {\n                tempState.ajaxRequesters[xhrsId] = optAjaxRequester;\n            }\n\n            return xhr;\n        },\n\n        // Deletes any local storage records that are \"expired\".\n        _removeExpiredChunkingRecords: function() {\n            var expirationDays = resume.recordsExpireIn;\n\n            handler._iterateResumeRecords(function(key, uploadData) {\n                var expirationDate = new Date(uploadData.lastUpdated);\n\n                // transform updated date into expiration date\n                expirationDate.setDate(expirationDate.getDate() + expirationDays);\n\n                if (expirationDate.getTime() <= Date.now()) {\n                    log(\"Removing expired resume record with key \" + key);\n                    localStorage.removeItem(key);\n                }\n            });\n        },\n\n        /**\n         * Determine if the associated file should be chunked.\n         *\n         * @param id ID of the associated file\n         * @returns {*} true if chunking is enabled, possible, and the file can be split into more than 1 part\n         */\n        _shouldChunkThisFile: function(id) {\n            var state = handler._getFileState(id);\n\n            // file may no longer be available if it was recently cancelled\n            if (state) {\n                if (!state.chunking) {\n                    handler.reevaluateChunking(id);\n                }\n\n                return state.chunking.enabled;\n            }\n        }\n    });\n};\n","/*globals qq, XMLHttpRequest*/\nqq.DeleteFileAjaxRequester = function(o) {\n    \"use strict\";\n\n    var requester,\n        options = {\n            method: \"DELETE\",\n            uuidParamName: \"qquuid\",\n            endpointStore: {},\n            maxConnections: 3,\n            customHeaders: function(id) {return {};},\n            paramsStore: {},\n            cors: {\n                expected: false,\n                sendCredentials: false\n            },\n            log: function(str, level) {},\n            onDelete: function(id) {},\n            onDeleteComplete: function(id, xhrOrXdr, isError) {}\n        };\n\n    qq.extend(options, o);\n\n    function getMandatedParams() {\n        if (options.method.toUpperCase() === \"POST\") {\n            return {\n                _method: \"DELETE\"\n            };\n        }\n\n        return {};\n    }\n\n    requester = qq.extend(this, new qq.AjaxRequester({\n        acceptHeader: \"application/json\",\n        validMethods: [\"POST\", \"DELETE\"],\n        method: options.method,\n        endpointStore: options.endpointStore,\n        paramsStore: options.paramsStore,\n        mandatedParams: getMandatedParams(),\n        maxConnections: options.maxConnections,\n        customHeaders: function(id) {\n            return options.customHeaders.get(id);\n        },\n        log: options.log,\n        onSend: options.onDelete,\n        onComplete: options.onDeleteComplete,\n        cors: options.cors\n    }));\n\n    qq.extend(this, {\n        sendDelete: function(id, uuid, additionalMandatedParams) {\n            var additionalOptions = additionalMandatedParams || {};\n\n            options.log(\"Submitting delete file request for \" + id);\n\n            if (options.method === \"DELETE\") {\n                requester.initTransport(id)\n                    .withPath(uuid)\n                    .withParams(additionalOptions)\n                    .send();\n            }\n            else {\n                additionalOptions[options.uuidParamName] = uuid;\n                requester.initTransport(id)\n                    .withParams(additionalOptions)\n                    .send();\n            }\n        }\n    });\n};\n","/*global qq, define */\n/*jshint strict:false,bitwise:false,nonew:false,asi:true,-W064,-W116,-W089 */\n/**\n * Mega pixel image rendering library for iOS6+\n *\n * Fixes iOS6+'s image file rendering issue for large size image (over mega-pixel),\n * which causes unexpected subsampling when drawing it in canvas.\n * By using this library, you can safely render the image with proper stretching.\n *\n * Copyright (c) 2012 Shinichi Tomita <shinichi.tomita@gmail.com>\n * Released under the MIT license\n *\n * Heavily modified by Widen for Fine Uploader\n */\n(function() {\n\n    /**\n     * Detect subsampling in loaded image.\n     * In iOS, larger images than 2M pixels may be subsampled in rendering.\n     */\n    function detectSubsampling(img) {\n        var iw = img.naturalWidth,\n            ih = img.naturalHeight,\n            canvas = document.createElement(\"canvas\"),\n            ctx;\n\n        if (iw * ih > 1024 * 1024) { // subsampling may happen over megapixel image\n            canvas.width = canvas.height = 1;\n            ctx = canvas.getContext(\"2d\");\n            ctx.drawImage(img, -iw + 1, 0);\n            // subsampled image becomes half smaller in rendering size.\n            // check alpha channel value to confirm image is covering edge pixel or not.\n            // if alpha value is 0 image is not covering, hence subsampled.\n            return ctx.getImageData(0, 0, 1, 1).data[3] === 0;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * Detecting vertical squash in loaded image.\n     * Fixes a bug which squash image vertically while drawing into canvas for some images.\n     */\n    function detectVerticalSquash(img, iw, ih) {\n        var canvas = document.createElement(\"canvas\"),\n            sy = 0,\n            ey = ih,\n            py = ih,\n            ctx, data, alpha, ratio;\n\n        canvas.width = 1;\n        canvas.height = ih;\n        ctx = canvas.getContext(\"2d\");\n        ctx.drawImage(img, 0, 0);\n        data = ctx.getImageData(0, 0, 1, ih).data;\n\n        // search image edge pixel position in case it is squashed vertically.\n        while (py > sy) {\n            alpha = data[(py - 1) * 4 + 3];\n            if (alpha === 0) {\n                ey = py;\n            } else {\n                sy = py;\n            }\n            py = (ey + sy) >> 1;\n        }\n\n        ratio = (py / ih);\n        return (ratio === 0) ? 1 : ratio;\n    }\n\n    /**\n     * Rendering image element (with resizing) and get its data URL\n     */\n    function renderImageToDataURL(img, blob, options, doSquash) {\n        var canvas = document.createElement(\"canvas\"),\n            mime = options.mime || \"image/jpeg\",\n            promise = new qq.Promise();\n\n        renderImageToCanvas(img, blob, canvas, options, doSquash)\n            .then(function() {\n                promise.success(\n                    canvas.toDataURL(mime, options.quality || 0.8)\n                );\n            });\n\n        return promise;\n    }\n\n    function maybeCalculateDownsampledDimensions(spec) {\n        var maxPixels = 5241000; //iOS specific value\n\n        if (!qq.ios()) {\n            throw new qq.Error(\"Downsampled dimensions can only be reliably calculated for iOS!\");\n        }\n\n        if (spec.origHeight * spec.origWidth > maxPixels) {\n            return {\n                newHeight: Math.round(Math.sqrt(maxPixels * (spec.origHeight / spec.origWidth))),\n                newWidth: Math.round(Math.sqrt(maxPixels * (spec.origWidth / spec.origHeight)))\n            };\n        }\n    }\n\n    /**\n     * Rendering image element (with resizing) into the canvas element\n     */\n    function renderImageToCanvas(img, blob, canvas, options, doSquash) {\n        var iw = img.naturalWidth,\n            ih = img.naturalHeight,\n            width = options.width,\n            height = options.height,\n            ctx = canvas.getContext(\"2d\"),\n            promise = new qq.Promise(),\n            modifiedDimensions;\n\n        ctx.save();\n\n        if (options.resize) {\n            return renderImageToCanvasWithCustomResizer({\n                blob: blob,\n                canvas: canvas,\n                image: img,\n                imageHeight: ih,\n                imageWidth: iw,\n                orientation: options.orientation,\n                resize: options.resize,\n                targetHeight: height,\n                targetWidth: width\n            });\n        }\n\n        if (!qq.supportedFeatures.unlimitedScaledImageSize) {\n            modifiedDimensions = maybeCalculateDownsampledDimensions({\n                origWidth: width,\n                origHeight: height\n            });\n\n            if (modifiedDimensions) {\n                qq.log(qq.format(\"Had to reduce dimensions due to device limitations from {}w / {}h to {}w / {}h\",\n                    width, height, modifiedDimensions.newWidth, modifiedDimensions.newHeight),\n                    \"warn\");\n\n                width = modifiedDimensions.newWidth;\n                height = modifiedDimensions.newHeight;\n            }\n        }\n\n        transformCoordinate(canvas, width, height, options.orientation);\n\n        // Fine Uploader specific: Save some CPU cycles if not using iOS\n        // Assumption: This logic is only needed to overcome iOS image sampling issues\n        if (qq.ios()) {\n            (function() {\n                if (detectSubsampling(img)) {\n                    iw /= 2;\n                    ih /= 2;\n                }\n\n                var d = 1024, // size of tiling canvas\n                    tmpCanvas = document.createElement(\"canvas\"),\n                    vertSquashRatio = doSquash ? detectVerticalSquash(img, iw, ih) : 1,\n                    dw = Math.ceil(d * width / iw),\n                    dh = Math.ceil(d * height / ih / vertSquashRatio),\n                    sy = 0,\n                    dy = 0,\n                    tmpCtx, sx, dx;\n\n                tmpCanvas.width = tmpCanvas.height = d;\n                tmpCtx = tmpCanvas.getContext(\"2d\");\n\n                while (sy < ih) {\n                    sx = 0;\n                    dx = 0;\n                    while (sx < iw) {\n                        tmpCtx.clearRect(0, 0, d, d);\n                        tmpCtx.drawImage(img, -sx, -sy);\n                        ctx.drawImage(tmpCanvas, 0, 0, d, d, dx, dy, dw, dh);\n                        sx += d;\n                        dx += dw;\n                    }\n                    sy += d;\n                    dy += dh;\n                }\n                ctx.restore();\n                tmpCanvas = tmpCtx = null;\n            }());\n        }\n        else {\n            ctx.drawImage(img, 0, 0, width, height);\n        }\n\n        canvas.qqImageRendered && canvas.qqImageRendered();\n        promise.success();\n\n        return promise;\n    }\n\n    function renderImageToCanvasWithCustomResizer(resizeInfo) {\n        var blob = resizeInfo.blob,\n            image = resizeInfo.image,\n            imageHeight = resizeInfo.imageHeight,\n            imageWidth = resizeInfo.imageWidth,\n            orientation = resizeInfo.orientation,\n            promise = new qq.Promise(),\n            resize = resizeInfo.resize,\n            sourceCanvas = document.createElement(\"canvas\"),\n            sourceCanvasContext = sourceCanvas.getContext(\"2d\"),\n            targetCanvas = resizeInfo.canvas,\n            targetHeight = resizeInfo.targetHeight,\n            targetWidth = resizeInfo.targetWidth;\n\n        transformCoordinate(sourceCanvas, imageWidth, imageHeight, orientation);\n\n        targetCanvas.height = targetHeight;\n        targetCanvas.width = targetWidth;\n\n        sourceCanvasContext.drawImage(image, 0, 0);\n\n        resize({\n            blob: blob,\n            height: targetHeight,\n            image: image,\n            sourceCanvas: sourceCanvas,\n            targetCanvas: targetCanvas,\n            width: targetWidth\n        })\n            .then(\n                function success() {\n                    targetCanvas.qqImageRendered && targetCanvas.qqImageRendered();\n                    promise.success();\n                },\n                promise.failure\n            );\n\n        return promise;\n    }\n\n    /**\n     * Transform canvas coordination according to specified frame size and orientation\n     * Orientation value is from EXIF tag\n     */\n    function transformCoordinate(canvas, width, height, orientation) {\n        switch (orientation) {\n            case 5:\n            case 6:\n            case 7:\n            case 8:\n                canvas.width = height;\n                canvas.height = width;\n                break;\n            default:\n                canvas.width = width;\n                canvas.height = height;\n        }\n        var ctx = canvas.getContext(\"2d\");\n        switch (orientation) {\n            case 2:\n                // horizontal flip\n                ctx.translate(width, 0);\n                ctx.scale(-1, 1);\n                break;\n            case 3:\n                // 180 rotate left\n                ctx.translate(width, height);\n                ctx.rotate(Math.PI);\n                break;\n            case 4:\n                // vertical flip\n                ctx.translate(0, height);\n                ctx.scale(1, -1);\n                break;\n            case 5:\n                // vertical flip + 90 rotate right\n                ctx.rotate(0.5 * Math.PI);\n                ctx.scale(1, -1);\n                break;\n            case 6:\n                // 90 rotate right\n                ctx.rotate(0.5 * Math.PI);\n                ctx.translate(0, -height);\n                break;\n            case 7:\n                // horizontal flip + 90 rotate right\n                ctx.rotate(0.5 * Math.PI);\n                ctx.translate(width, -height);\n                ctx.scale(-1, 1);\n                break;\n            case 8:\n                // 90 rotate left\n                ctx.rotate(-0.5 * Math.PI);\n                ctx.translate(-width, 0);\n                break;\n            default:\n                break;\n        }\n    }\n\n    /**\n     * MegaPixImage class\n     */\n    function MegaPixImage(srcImage, errorCallback) {\n        var self = this;\n\n        if (window.Blob && srcImage instanceof Blob) {\n            (function() {\n                var img = new Image(),\n                    URL = window.URL && window.URL.createObjectURL ? window.URL :\n                        window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL : null;\n                if (!URL) { throw Error(\"No createObjectURL function found to create blob url\"); }\n                img.src = URL.createObjectURL(srcImage);\n                self.blob = srcImage;\n                srcImage = img;\n            }());\n        }\n        if (!srcImage.naturalWidth && !srcImage.naturalHeight) {\n            srcImage.onload = function() {\n                var listeners = self.imageLoadListeners;\n                if (listeners) {\n                    self.imageLoadListeners = null;\n                    // IE11 doesn't reliably report actual image dimensions immediately after onload for small files,\n                    // so let's push this to the end of the UI thread queue.\n                    setTimeout(function() {\n                        for (var i = 0, len = listeners.length; i < len; i++) {\n                            listeners[i]();\n                        }\n                    }, 0);\n                }\n            };\n            srcImage.onerror = errorCallback;\n            this.imageLoadListeners = [];\n        }\n        this.srcImage = srcImage;\n    }\n\n    /**\n     * Rendering megapix image into specified target element\n     */\n    MegaPixImage.prototype.render = function(target, options) {\n        options = options || {};\n\n        var self = this,\n            imgWidth = this.srcImage.naturalWidth,\n            imgHeight = this.srcImage.naturalHeight,\n            width = options.width,\n            height = options.height,\n            maxWidth = options.maxWidth,\n            maxHeight = options.maxHeight,\n            doSquash = !this.blob || this.blob.type === \"image/jpeg\",\n            tagName = target.tagName.toLowerCase(),\n            opt;\n\n        if (this.imageLoadListeners) {\n            this.imageLoadListeners.push(function() { self.render(target, options); });\n            return;\n        }\n\n        if (width && !height) {\n            height = (imgHeight * width / imgWidth) << 0;\n        } else if (height && !width) {\n            width = (imgWidth * height / imgHeight) << 0;\n        } else {\n            width = imgWidth;\n            height = imgHeight;\n        }\n        if (maxWidth && width > maxWidth) {\n            width = maxWidth;\n            height = (imgHeight * width / imgWidth) << 0;\n        }\n        if (maxHeight && height > maxHeight) {\n            height = maxHeight;\n            width = (imgWidth * height / imgHeight) << 0;\n        }\n\n        opt = { width: width, height: height },\n        qq.each(options, function(optionsKey, optionsValue) {\n            opt[optionsKey] = optionsValue;\n        });\n\n        if (tagName === \"img\") {\n            (function() {\n                var oldTargetSrc = target.src;\n                renderImageToDataURL(self.srcImage, self.blob, opt, doSquash)\n                    .then(function(dataUri) {\n                        target.src = dataUri;\n                        oldTargetSrc === target.src && target.onload();\n                    });\n            }());\n        } else if (tagName === \"canvas\") {\n            renderImageToCanvas(this.srcImage, this.blob, target, opt, doSquash);\n        }\n        if (typeof this.onrender === \"function\") {\n            this.onrender(target);\n        }\n    };\n\n    qq.MegaPixImage = MegaPixImage;\n})();\n","/*globals qq */\n/**\n * Draws a thumbnail of a Blob/File/URL onto an <img> or <canvas>.\n *\n * @constructor\n */\nqq.ImageGenerator = function(log) {\n    \"use strict\";\n\n    function isImg(el) {\n        return el.tagName.toLowerCase() === \"img\";\n    }\n\n    function isCanvas(el) {\n        return el.tagName.toLowerCase() === \"canvas\";\n    }\n\n    function isImgCorsSupported() {\n        return new Image().crossOrigin !== undefined;\n    }\n\n    function isCanvasSupported() {\n        var canvas = document.createElement(\"canvas\");\n\n        return canvas.getContext && canvas.getContext(\"2d\");\n    }\n\n    // This is only meant to determine the MIME type of a renderable image file.\n    // It is used to ensure images drawn from a URL that have transparent backgrounds\n    // are rendered correctly, among other things.\n    function determineMimeOfFileName(nameWithPath) {\n        /*jshint -W015 */\n        var pathSegments = nameWithPath.split(\"/\"),\n            name = pathSegments[pathSegments.length - 1].split(\"?\")[0],\n            extension = qq.getExtension(name);\n\n        extension = extension && extension.toLowerCase();\n\n        switch (extension) {\n            case \"jpeg\":\n            case \"jpg\":\n                return \"image/jpeg\";\n            case \"png\":\n                return \"image/png\";\n            case \"bmp\":\n                return \"image/bmp\";\n            case \"gif\":\n                return \"image/gif\";\n            case \"tiff\":\n            case \"tif\":\n                return \"image/tiff\";\n        }\n    }\n\n    // This will likely not work correctly in IE8 and older.\n    // It's only used as part of a formula to determine\n    // if a canvas can be used to scale a server-hosted thumbnail.\n    // If canvas isn't supported by the UA (IE8 and older)\n    // this method should not even be called.\n    function isCrossOrigin(url) {\n        var targetAnchor = document.createElement(\"a\"),\n            targetProtocol, targetHostname, targetPort;\n\n        targetAnchor.href = url;\n\n        targetProtocol = targetAnchor.protocol;\n        targetPort = targetAnchor.port;\n        targetHostname = targetAnchor.hostname;\n\n        if (targetProtocol.toLowerCase() !== window.location.protocol.toLowerCase()) {\n            return true;\n        }\n\n        if (targetHostname.toLowerCase() !== window.location.hostname.toLowerCase()) {\n            return true;\n        }\n\n        // IE doesn't take ports into consideration when determining if two endpoints are same origin.\n        if (targetPort !== window.location.port && !qq.ie()) {\n            return true;\n        }\n\n        return false;\n    }\n\n    function registerImgLoadListeners(img, promise) {\n        img.onload = function() {\n            img.onload = null;\n            img.onerror = null;\n            promise.success(img);\n        };\n\n        img.onerror = function() {\n            img.onload = null;\n            img.onerror = null;\n            log(\"Problem drawing thumbnail!\", \"error\");\n            promise.failure(img, \"Problem drawing thumbnail!\");\n        };\n    }\n\n    function registerCanvasDrawImageListener(canvas, promise) {\n        // The image is drawn on the canvas by a third-party library,\n        // and we want to know when this is completed.  Since the library\n        // may invoke drawImage many times in a loop, we need to be called\n        // back when the image is fully rendered.  So, we are expecting the\n        // code that draws this image to follow a convention that involves a\n        // function attached to the canvas instance be invoked when it is done.\n        canvas.qqImageRendered = function() {\n            promise.success(canvas);\n        };\n    }\n\n    // Fulfills a `qq.Promise` when an image has been drawn onto the target,\n    // whether that is a <canvas> or an <img>.  The attempt is considered a\n    // failure if the target is not an <img> or a <canvas>, or if the drawing\n    // attempt was not successful.\n    function registerThumbnailRenderedListener(imgOrCanvas, promise) {\n        var registered = isImg(imgOrCanvas) || isCanvas(imgOrCanvas);\n\n        if (isImg(imgOrCanvas)) {\n            registerImgLoadListeners(imgOrCanvas, promise);\n        }\n        else if (isCanvas(imgOrCanvas)) {\n            registerCanvasDrawImageListener(imgOrCanvas, promise);\n        }\n        else {\n            promise.failure(imgOrCanvas);\n            log(qq.format(\"Element container of type {} is not supported!\", imgOrCanvas.tagName), \"error\");\n        }\n\n        return registered;\n    }\n\n    // Draw a preview iff the current UA can natively display it.\n    // Also rotate the image if necessary.\n    function draw(fileOrBlob, container, options) {\n        var drawPreview = new qq.Promise(),\n            identifier = new qq.Identify(fileOrBlob, log),\n            maxSize = options.maxSize,\n            // jshint eqnull:true\n            orient = options.orient == null ? true : options.orient,\n            megapixErrorHandler = function() {\n                container.onerror = null;\n                container.onload = null;\n                log(\"Could not render preview, file may be too large!\", \"error\");\n                drawPreview.failure(container, \"Browser cannot render image!\");\n            };\n\n        identifier.isPreviewable().then(\n            function(mime) {\n                // If options explicitly specify that Orientation is not desired,\n                // replace the orient task with a dummy promise that \"succeeds\" immediately.\n                var dummyExif = {\n                        parse: function() {\n                            return new qq.Promise().success();\n                        }\n                    },\n                    exif = orient ? new qq.Exif(fileOrBlob, log) : dummyExif,\n                    mpImg = new qq.MegaPixImage(fileOrBlob, megapixErrorHandler);\n\n                if (registerThumbnailRenderedListener(container, drawPreview)) {\n                    exif.parse().then(\n                        function(exif) {\n                            var orientation = exif && exif.Orientation;\n\n                            mpImg.render(container, {\n                                maxWidth: maxSize,\n                                maxHeight: maxSize,\n                                orientation: orientation,\n                                mime: mime,\n                                resize: options.customResizeFunction\n                            });\n                        },\n\n                        function(failureMsg) {\n                            log(qq.format(\"EXIF data could not be parsed ({}).  Assuming orientation = 1.\", failureMsg));\n\n                            mpImg.render(container, {\n                                maxWidth: maxSize,\n                                maxHeight: maxSize,\n                                mime: mime,\n                                resize: options.customResizeFunction\n                            });\n                        }\n                    );\n                }\n            },\n\n            function() {\n                log(\"Not previewable\");\n                drawPreview.failure(container, \"Not previewable\");\n            }\n        );\n\n        return drawPreview;\n    }\n\n    function drawOnCanvasOrImgFromUrl(url, canvasOrImg, draw, maxSize, customResizeFunction) {\n        var tempImg = new Image(),\n            tempImgRender = new qq.Promise();\n\n        registerThumbnailRenderedListener(tempImg, tempImgRender);\n\n        if (isCrossOrigin(url)) {\n            tempImg.crossOrigin = \"anonymous\";\n        }\n\n        tempImg.src = url;\n\n        tempImgRender.then(\n            function rendered() {\n                registerThumbnailRenderedListener(canvasOrImg, draw);\n\n                var mpImg = new qq.MegaPixImage(tempImg);\n                mpImg.render(canvasOrImg, {\n                    maxWidth: maxSize,\n                    maxHeight: maxSize,\n                    mime: determineMimeOfFileName(url),\n                    resize: customResizeFunction\n                });\n            },\n\n            draw.failure\n        );\n    }\n\n    function drawOnImgFromUrlWithCssScaling(url, img, draw, maxSize) {\n        registerThumbnailRenderedListener(img, draw);\n        // NOTE: The fact that maxWidth/height is set on the thumbnail for scaled images\n        // that must drop back to CSS is known and exploited by the templating module.\n        // In this module, we pre-render \"waiting\" thumbs for all files immediately after they\n        // are submitted, and we must be sure to pass any style associated with the \"waiting\" preview.\n        qq(img).css({\n            maxWidth: maxSize + \"px\",\n            maxHeight: maxSize + \"px\"\n        });\n\n        img.src = url;\n    }\n\n    // Draw a (server-hosted) thumbnail given a URL.\n    // This will optionally scale the thumbnail as well.\n    // It attempts to use <canvas> to scale, but will fall back\n    // to max-width and max-height style properties if the UA\n    // doesn't support canvas or if the images is cross-domain and\n    // the UA doesn't support the crossorigin attribute on img tags,\n    // which is required to scale a cross-origin image using <canvas> &\n    // then export it back to an <img>.\n    function drawFromUrl(url, container, options) {\n        var draw = new qq.Promise(),\n            scale = options.scale,\n            maxSize = scale ? options.maxSize : null;\n\n        // container is an img, scaling needed\n        if (scale && isImg(container)) {\n            // Iff canvas is available in this UA, try to use it for scaling.\n            // Otherwise, fall back to CSS scaling\n            if (isCanvasSupported()) {\n                // Attempt to use <canvas> for image scaling,\n                // but we must fall back to scaling via CSS/styles\n                // if this is a cross-origin image and the UA doesn't support <img> CORS.\n                if (isCrossOrigin(url) && !isImgCorsSupported()) {\n                    drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);\n                }\n                else {\n                    drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);\n                }\n            }\n            else {\n                drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);\n            }\n        }\n        // container is a canvas, scaling optional\n        else if (isCanvas(container)) {\n            drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);\n        }\n        // container is an img & no scaling: just set the src attr to the passed url\n        else if (registerThumbnailRenderedListener(container, draw)) {\n            container.src = url;\n        }\n\n        return draw;\n    }\n\n    qq.extend(this, {\n        /**\n         * Generate a thumbnail.  Depending on the arguments, this may either result in\n         * a client-side rendering of an image (if a `Blob` is supplied) or a server-generated\n         * image that may optionally be scaled client-side using <canvas> or CSS/styles (as a fallback).\n         *\n         * @param fileBlobOrUrl a `File`, `Blob`, or a URL pointing to the image\n         * @param container <img> or <canvas> to contain the preview\n         * @param options possible properties include `maxSize` (int), `orient` (bool - default true), resize` (bool - default true), and `customResizeFunction`.\n         * @returns qq.Promise fulfilled when the preview has been drawn, or the attempt has failed\n         */\n        generate: function(fileBlobOrUrl, container, options) {\n            if (qq.isString(fileBlobOrUrl)) {\n                log(\"Attempting to update thumbnail based on server response.\");\n                return drawFromUrl(fileBlobOrUrl, container, options || {});\n            }\n            else {\n                log(\"Attempting to draw client-side image preview.\");\n                return draw(fileBlobOrUrl, container, options || {});\n            }\n        }\n    });\n\n    /*<testing>*/\n    this._testing = {};\n    this._testing.isImg = isImg;\n    this._testing.isCanvas = isCanvas;\n    this._testing.isCrossOrigin = isCrossOrigin;\n    this._testing.determineMimeOfFileName = determineMimeOfFileName;\n    /*</testing>*/\n};\n","/*globals qq */\n/**\n * EXIF image data parser.  Currently only parses the Orientation tag value,\n * but this may be expanded to other tags in the future.\n *\n * @param fileOrBlob Attempt to parse EXIF data in this `Blob`\n * @constructor\n */\nqq.Exif = function(fileOrBlob, log) {\n    \"use strict\";\n\n    // Orientation is the only tag parsed here at this time.\n    var TAG_IDS = [274],\n        TAG_INFO = {\n            274: {\n                name: \"Orientation\",\n                bytes: 2\n            }\n        };\n\n    // Convert a little endian (hex string) to big endian (decimal).\n    function parseLittleEndian(hex) {\n        var result = 0,\n            pow = 0;\n\n        while (hex.length > 0) {\n            result += parseInt(hex.substring(0, 2), 16) * Math.pow(2, pow);\n            hex = hex.substring(2, hex.length);\n            pow += 8;\n        }\n\n        return result;\n    }\n\n    // Find the byte offset, of Application Segment 1 (EXIF).\n    // External callers need not supply any arguments.\n    function seekToApp1(offset, promise) {\n        var theOffset = offset,\n            thePromise = promise;\n        if (theOffset === undefined) {\n            theOffset = 2;\n            thePromise = new qq.Promise();\n        }\n\n        qq.readBlobToHex(fileOrBlob, theOffset, 4).then(function(hex) {\n            var match = /^ffe([0-9])/.exec(hex),\n                segmentLength;\n\n            if (match) {\n                if (match[1] !== \"1\") {\n                    segmentLength = parseInt(hex.slice(4, 8), 16);\n                    seekToApp1(theOffset + segmentLength + 2, thePromise);\n                }\n                else {\n                    thePromise.success(theOffset);\n                }\n            }\n            else {\n                thePromise.failure(\"No EXIF header to be found!\");\n            }\n        });\n\n        return thePromise;\n    }\n\n    // Find the byte offset of Application Segment 1 (EXIF) for valid JPEGs only.\n    function getApp1Offset() {\n        var promise = new qq.Promise();\n\n        qq.readBlobToHex(fileOrBlob, 0, 6).then(function(hex) {\n            if (hex.indexOf(\"ffd8\") !== 0) {\n                promise.failure(\"Not a valid JPEG!\");\n            }\n            else {\n                seekToApp1().then(function(offset) {\n                    promise.success(offset);\n                },\n                function(error) {\n                    promise.failure(error);\n                });\n            }\n        });\n\n        return promise;\n    }\n\n    // Determine the byte ordering of the EXIF header.\n    function isLittleEndian(app1Start) {\n        var promise = new qq.Promise();\n\n        qq.readBlobToHex(fileOrBlob, app1Start + 10, 2).then(function(hex) {\n            promise.success(hex === \"4949\");\n        });\n\n        return promise;\n    }\n\n    // Determine the number of directory entries in the EXIF header.\n    function getDirEntryCount(app1Start, littleEndian) {\n        var promise = new qq.Promise();\n\n        qq.readBlobToHex(fileOrBlob, app1Start + 18, 2).then(function(hex) {\n            if (littleEndian) {\n                return promise.success(parseLittleEndian(hex));\n            }\n            else {\n                promise.success(parseInt(hex, 16));\n            }\n        });\n\n        return promise;\n    }\n\n    // Get the IFD portion of the EXIF header as a hex string.\n    function getIfd(app1Start, dirEntries) {\n        var offset = app1Start + 20,\n            bytes = dirEntries * 12;\n\n        return qq.readBlobToHex(fileOrBlob, offset, bytes);\n    }\n\n    // Obtain an array of all directory entries (as hex strings) in the EXIF header.\n    function getDirEntries(ifdHex) {\n        var entries = [],\n            offset = 0;\n\n        while (offset + 24 <= ifdHex.length) {\n            entries.push(ifdHex.slice(offset, offset + 24));\n            offset += 24;\n        }\n\n        return entries;\n    }\n\n    // Obtain values for all relevant tags and return them.\n    function getTagValues(littleEndian, dirEntries) {\n        var TAG_VAL_OFFSET = 16,\n            tagsToFind = qq.extend([], TAG_IDS),\n            vals = {};\n\n        qq.each(dirEntries, function(idx, entry) {\n            var idHex = entry.slice(0, 4),\n                id = littleEndian ? parseLittleEndian(idHex) : parseInt(idHex, 16),\n                tagsToFindIdx = tagsToFind.indexOf(id),\n                tagValHex, tagName, tagValLength;\n\n            if (tagsToFindIdx >= 0) {\n                tagName = TAG_INFO[id].name;\n                tagValLength = TAG_INFO[id].bytes;\n                tagValHex = entry.slice(TAG_VAL_OFFSET, TAG_VAL_OFFSET + (tagValLength * 2));\n                vals[tagName] = littleEndian ? parseLittleEndian(tagValHex) : parseInt(tagValHex, 16);\n\n                tagsToFind.splice(tagsToFindIdx, 1);\n            }\n\n            if (tagsToFind.length === 0) {\n                return false;\n            }\n        });\n\n        return vals;\n    }\n\n    qq.extend(this, {\n        /**\n         * Attempt to parse the EXIF header for the `Blob` associated with this instance.\n         *\n         * @returns {qq.Promise} To be fulfilled when the parsing is complete.\n         * If successful, the parsed EXIF header as an object will be included.\n         */\n        parse: function() {\n            var parser = new qq.Promise(),\n                onParseFailure = function(message) {\n                    log(qq.format(\"EXIF header parse failed: '{}' \", message));\n                    parser.failure(message);\n                };\n\n            getApp1Offset().then(function(app1Offset) {\n                log(qq.format(\"Moving forward with EXIF header parsing for '{}'\", fileOrBlob.name === undefined ? \"blob\" : fileOrBlob.name));\n\n                isLittleEndian(app1Offset).then(function(littleEndian) {\n\n                    log(qq.format(\"EXIF Byte order is {} endian\", littleEndian ? \"little\" : \"big\"));\n\n                    getDirEntryCount(app1Offset, littleEndian).then(function(dirEntryCount) {\n\n                        log(qq.format(\"Found {} APP1 directory entries\", dirEntryCount));\n\n                        getIfd(app1Offset, dirEntryCount).then(function(ifdHex) {\n                            var dirEntries = getDirEntries(ifdHex),\n                                tagValues = getTagValues(littleEndian, dirEntries);\n\n                            log(\"Successfully parsed some EXIF tags\");\n\n                            parser.success(tagValues);\n                        }, onParseFailure);\n                    }, onParseFailure);\n                }, onParseFailure);\n            }, onParseFailure);\n\n            return parser;\n        }\n    });\n\n    /*<testing>*/\n    this._testing = {};\n    this._testing.parseLittleEndian = parseLittleEndian;\n    /*</testing>*/\n};\n","/*globals qq */\nqq.Identify = function(fileOrBlob, log) {\n    \"use strict\";\n\n    function isIdentifiable(magicBytes, questionableBytes) {\n        var identifiable = false,\n            magicBytesEntries = [].concat(magicBytes);\n\n        qq.each(magicBytesEntries, function(idx, magicBytesArrayEntry) {\n            if (questionableBytes.indexOf(magicBytesArrayEntry) === 0) {\n                identifiable = true;\n                return false;\n            }\n        });\n\n        return identifiable;\n    }\n\n    qq.extend(this, {\n        /**\n         * Determines if a Blob can be displayed natively in the current browser.  This is done by reading magic\n         * bytes in the beginning of the file, so this is an asynchronous operation.  Before we attempt to read the\n         * file, we will examine the blob's type attribute to save CPU cycles.\n         *\n         * @returns {qq.Promise} Promise that is fulfilled when identification is complete.\n         * If successful, the MIME string is passed to the success handler.\n         */\n        isPreviewable: function() {\n            var self = this,\n                identifier = new qq.Promise(),\n                previewable = false,\n                name = fileOrBlob.name === undefined ? \"blob\" : fileOrBlob.name;\n\n            log(qq.format(\"Attempting to determine if {} can be rendered in this browser\", name));\n\n            log(\"First pass: check type attribute of blob object.\");\n\n            if (this.isPreviewableSync()) {\n                log(\"Second pass: check for magic bytes in file header.\");\n\n                qq.readBlobToHex(fileOrBlob, 0, 4).then(function(hex) {\n                    qq.each(self.PREVIEWABLE_MIME_TYPES, function(mime, bytes) {\n                        if (isIdentifiable(bytes, hex)) {\n                            // Safari is the only supported browser that can deal with TIFFs natively,\n                            // so, if this is a TIFF and the UA isn't Safari, declare this file \"non-previewable\".\n                            if (mime !== \"image/tiff\" || qq.supportedFeatures.tiffPreviews) {\n                                previewable = true;\n                                identifier.success(mime);\n                            }\n\n                            return false;\n                        }\n                    });\n\n                    log(qq.format(\"'{}' is {} able to be rendered in this browser\", name, previewable ? \"\" : \"NOT\"));\n\n                    if (!previewable) {\n                        identifier.failure();\n                    }\n                },\n                function() {\n                    log(\"Error reading file w/ name '\" + name + \"'.  Not able to be rendered in this browser.\");\n                    identifier.failure();\n                });\n            }\n            else {\n                identifier.failure();\n            }\n\n            return identifier;\n        },\n\n        /**\n         * Determines if a Blob can be displayed natively in the current browser.  This is done by checking the\n         * blob's type attribute.  This is a synchronous operation, useful for situations where an asynchronous operation\n         * would be challenging to support.  Note that the blob's type property is not as accurate as reading the\n         * file's magic bytes.\n         *\n         * @returns {Boolean} true if the blob can be rendered in the current browser\n         */\n        isPreviewableSync: function() {\n            var fileMime = fileOrBlob.type,\n                // Assumption: This will only ever be executed in browsers that support `Object.keys`.\n                isRecognizedImage = qq.indexOf(Object.keys(this.PREVIEWABLE_MIME_TYPES), fileMime) >= 0,\n                previewable = false,\n                name = fileOrBlob.name === undefined ? \"blob\" : fileOrBlob.name;\n\n            if (isRecognizedImage) {\n                if (fileMime === \"image/tiff\") {\n                    previewable = qq.supportedFeatures.tiffPreviews;\n                }\n                else {\n                    previewable = true;\n                }\n            }\n\n            !previewable && log(name + \" is not previewable in this browser per the blob's type attr\");\n\n            return previewable;\n        }\n    });\n};\n\nqq.Identify.prototype.PREVIEWABLE_MIME_TYPES = {\n    \"image/jpeg\": \"ffd8ff\",\n    \"image/gif\": \"474946\",\n    \"image/png\": \"89504e\",\n    \"image/bmp\": \"424d\",\n    \"image/tiff\": [\"49492a00\", \"4d4d002a\"]\n};\n","/*globals qq*/\n/**\n * Attempts to validate an image, wherever possible.\n *\n * @param blob File or Blob representing a user-selecting image.\n * @param log Uses this to post log messages to the console.\n * @constructor\n */\nqq.ImageValidation = function(blob, log) {\n    \"use strict\";\n\n    /**\n     * @param limits Object with possible image-related limits to enforce.\n     * @returns {boolean} true if at least one of the limits has a non-zero value\n     */\n    function hasNonZeroLimits(limits) {\n        var atLeastOne = false;\n\n        qq.each(limits, function(limit, value) {\n            if (value > 0) {\n                atLeastOne = true;\n                return false;\n            }\n        });\n\n        return atLeastOne;\n    }\n\n    /**\n     * @returns {qq.Promise} The promise is a failure if we can't obtain the width & height.\n     * Otherwise, `success` is called on the returned promise with an object containing\n     * `width` and `height` properties.\n     */\n    function getWidthHeight() {\n        var sizeDetermination = new qq.Promise();\n\n        new qq.Identify(blob, log).isPreviewable().then(function() {\n            var image = new Image(),\n                url = window.URL && window.URL.createObjectURL ? window.URL :\n                      window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL :\n                      null;\n\n            if (url) {\n                image.onerror = function() {\n                    log(\"Cannot determine dimensions for image.  May be too large.\", \"error\");\n                    sizeDetermination.failure();\n                };\n\n                image.onload = function() {\n                    sizeDetermination.success({\n                        width: this.width,\n                        height: this.height\n                    });\n                };\n\n                image.src = url.createObjectURL(blob);\n            }\n            else {\n                log(\"No createObjectURL function available to generate image URL!\", \"error\");\n                sizeDetermination.failure();\n            }\n        }, sizeDetermination.failure);\n\n        return sizeDetermination;\n    }\n\n    /**\n     *\n     * @param limits Object with possible image-related limits to enforce.\n     * @param dimensions Object containing `width` & `height` properties for the image to test.\n     * @returns {String || undefined} The name of the failing limit.  Undefined if no failing limits.\n     */\n    function getFailingLimit(limits, dimensions) {\n        var failingLimit;\n\n        qq.each(limits, function(limitName, limitValue) {\n            if (limitValue > 0) {\n                var limitMatcher = /(max|min)(Width|Height)/.exec(limitName),\n                    dimensionPropName = limitMatcher[2].charAt(0).toLowerCase() + limitMatcher[2].slice(1),\n                    actualValue = dimensions[dimensionPropName];\n\n                /*jshint -W015*/\n                switch (limitMatcher[1]) {\n                    case \"min\":\n                        if (actualValue < limitValue) {\n                            failingLimit = limitName;\n                            return false;\n                        }\n                        break;\n                    case \"max\":\n                        if (actualValue > limitValue) {\n                            failingLimit = limitName;\n                            return false;\n                        }\n                        break;\n                }\n            }\n        });\n\n        return failingLimit;\n    }\n\n    /**\n     * Validate the associated blob.\n     *\n     * @param limits\n     * @returns {qq.Promise} `success` is called on the promise is the image is valid or\n     * if the blob is not an image, or if the image is not verifiable.\n     * Otherwise, `failure` with the name of the failing limit.\n     */\n    this.validate = function(limits) {\n        var validationEffort = new qq.Promise();\n\n        log(\"Attempting to validate image.\");\n\n        if (hasNonZeroLimits(limits)) {\n            getWidthHeight().then(function(dimensions) {\n                var failingLimit = getFailingLimit(limits, dimensions);\n\n                if (failingLimit) {\n                    validationEffort.failure(failingLimit);\n                }\n                else {\n                    validationEffort.success();\n                }\n            }, validationEffort.success);\n        }\n        else {\n            validationEffort.success();\n        }\n\n        return validationEffort;\n    };\n};\n","/* globals qq */\n/**\n * Module used to control populating the initial list of files.\n *\n * @constructor\n */\nqq.Session = function(spec) {\n    \"use strict\";\n\n    var options = {\n        endpoint: null,\n        params: {},\n        customHeaders: {},\n        cors: {},\n        addFileRecord: function(sessionData) {},\n        log: function(message, level) {}\n    };\n\n    qq.extend(options, spec, true);\n\n    function isJsonResponseValid(response) {\n        if (qq.isArray(response)) {\n            return true;\n        }\n\n        options.log(\"Session response is not an array.\", \"error\");\n    }\n\n    function handleFileItems(fileItems, success, xhrOrXdr, promise) {\n        var someItemsIgnored = false;\n\n        success = success && isJsonResponseValid(fileItems);\n\n        if (success) {\n            qq.each(fileItems, function(idx, fileItem) {\n                /* jshint eqnull:true */\n                if (fileItem.uuid == null) {\n                    someItemsIgnored = true;\n                    options.log(qq.format(\"Session response item {} did not include a valid UUID - ignoring.\", idx), \"error\");\n                }\n                else if (fileItem.name == null) {\n                    someItemsIgnored = true;\n                    options.log(qq.format(\"Session response item {} did not include a valid name - ignoring.\", idx), \"error\");\n                }\n                else {\n                    try {\n                        options.addFileRecord(fileItem);\n                        return true;\n                    }\n                    catch (err) {\n                        someItemsIgnored = true;\n                        options.log(err.message, \"error\");\n                    }\n                }\n\n                return false;\n            });\n        }\n\n        promise[success && !someItemsIgnored ? \"success\" : \"failure\"](fileItems, xhrOrXdr);\n    }\n\n    // Initiate a call to the server that will be used to populate the initial file list.\n    // Returns a `qq.Promise`.\n    this.refresh = function() {\n        /*jshint indent:false */\n        var refreshEffort = new qq.Promise(),\n            refreshCompleteCallback = function(response, success, xhrOrXdr) {\n                handleFileItems(response, success, xhrOrXdr, refreshEffort);\n            },\n            requesterOptions = qq.extend({}, options),\n            requester = new qq.SessionAjaxRequester(\n                qq.extend(requesterOptions, {onComplete: refreshCompleteCallback})\n            );\n\n        requester.queryServer();\n\n        return refreshEffort;\n    };\n};\n","/*globals qq, XMLHttpRequest*/\n/**\n * Thin module used to send GET requests to the server, expecting information about session\n * data used to initialize an uploader instance.\n *\n * @param spec Various options used to influence the associated request.\n * @constructor\n */\nqq.SessionAjaxRequester = function(spec) {\n    \"use strict\";\n\n    var requester,\n        options = {\n            endpoint: null,\n            customHeaders: {},\n            params: {},\n            cors: {\n                expected: false,\n                sendCredentials: false\n            },\n            onComplete: function(response, success, xhrOrXdr) {},\n            log: function(str, level) {}\n        };\n\n    qq.extend(options, spec);\n\n    function onComplete(id, xhrOrXdr, isError) {\n        var response = null;\n\n        /* jshint eqnull:true */\n        if (xhrOrXdr.responseText != null) {\n            try {\n                response = qq.parseJson(xhrOrXdr.responseText);\n            }\n            catch (err) {\n                options.log(\"Problem parsing session response: \" + err.message, \"error\");\n                isError = true;\n            }\n        }\n\n        options.onComplete(response, !isError, xhrOrXdr);\n    }\n\n    requester = qq.extend(this, new qq.AjaxRequester({\n        acceptHeader: \"application/json\",\n        validMethods: [\"GET\"],\n        method: \"GET\",\n        endpointStore: {\n            get: function() {\n                return options.endpoint;\n            }\n        },\n        customHeaders: options.customHeaders,\n        log: options.log,\n        onComplete: onComplete,\n        cors: options.cors\n    }));\n\n    qq.extend(this, {\n        queryServer: function() {\n            var params = qq.extend({}, options.params);\n\n            options.log(\"Session query request.\");\n\n            requester.initTransport(\"sessionRefresh\")\n                .withParams(params)\n                .withCacheBuster()\n                .send();\n        }\n    });\n};\n","/* globals qq, ExifRestorer */\n/**\n * Controls generation of scaled images based on a reference image encapsulated in a `File` or `Blob`.\n * Scaled images are generated and converted to blobs on-demand.\n * Multiple scaled images per reference image with varying sizes and other properties are supported.\n *\n * @param spec Information about the scaled images to generate.\n * @param log Logger instance\n * @constructor\n */\nqq.Scaler = function(spec, log) {\n    \"use strict\";\n\n    var self = this,\n        customResizeFunction = spec.customResizer,\n        includeOriginal = spec.sendOriginal,\n        orient = spec.orient,\n        defaultType = spec.defaultType,\n        defaultQuality = spec.defaultQuality / 100,\n        failedToScaleText = spec.failureText,\n        includeExif = spec.includeExif,\n        sizes = this._getSortedSizes(spec.sizes);\n\n    // Revealed API for instances of this module\n    qq.extend(this, {\n        // If no targeted sizes have been declared or if this browser doesn't support\n        // client-side image preview generation, there is no scaling to do.\n        enabled: qq.supportedFeatures.scaling && sizes.length > 0,\n\n        getFileRecords: function(originalFileUuid, originalFileName, originalBlobOrBlobData) {\n            var self = this,\n                records = [],\n                originalBlob = originalBlobOrBlobData.blob ? originalBlobOrBlobData.blob : originalBlobOrBlobData,\n                identifier = new qq.Identify(originalBlob, log);\n\n            // If the reference file cannot be rendered natively, we can't create scaled versions.\n            if (identifier.isPreviewableSync()) {\n                // Create records for each scaled version & add them to the records array, smallest first.\n                qq.each(sizes, function(idx, sizeRecord) {\n                    var outputType = self._determineOutputType({\n                        defaultType: defaultType,\n                        requestedType: sizeRecord.type,\n                        refType: originalBlob.type\n                    });\n\n                    records.push({\n                        uuid: qq.getUniqueId(),\n                        name: self._getName(originalFileName, {\n                            name: sizeRecord.name,\n                            type: outputType,\n                            refType: originalBlob.type\n                        }),\n                        blob: new qq.BlobProxy(originalBlob,\n                        qq.bind(self._generateScaledImage, self, {\n                            customResizeFunction: customResizeFunction,\n                            maxSize: sizeRecord.maxSize,\n                            orient: orient,\n                            type: outputType,\n                            quality: defaultQuality,\n                            failedText: failedToScaleText,\n                            includeExif: includeExif,\n                            log: log\n                        }))\n                    });\n                });\n\n                records.push({\n                    uuid: originalFileUuid,\n                    name: originalFileName,\n                    size: originalBlob.size,\n                    blob: includeOriginal ? originalBlob : null\n                });\n            }\n            else {\n                records.push({\n                    uuid: originalFileUuid,\n                    name: originalFileName,\n                    size: originalBlob.size,\n                    blob: originalBlob\n                });\n            }\n\n            return records;\n        },\n\n        handleNewFile: function(file, name, uuid, size, fileList, batchId, uuidParamName, api) {\n            var self = this,\n                buttonId = file.qqButtonId || (file.blob && file.blob.qqButtonId),\n                scaledIds = [],\n                originalId = null,\n                addFileToHandler = api.addFileToHandler,\n                uploadData = api.uploadData,\n                paramsStore = api.paramsStore,\n                proxyGroupId = qq.getUniqueId();\n\n            qq.each(self.getFileRecords(uuid, name, file), function(idx, record) {\n                var blobSize = record.size,\n                    id;\n\n                if (record.blob instanceof qq.BlobProxy) {\n                    blobSize = -1;\n                }\n\n                id = uploadData.addFile({\n                    uuid: record.uuid,\n                    name: record.name,\n                    size: blobSize,\n                    batchId: batchId,\n                    proxyGroupId: proxyGroupId\n                });\n\n                if (record.blob instanceof qq.BlobProxy) {\n                    scaledIds.push(id);\n                }\n                else {\n                    originalId = id;\n                }\n\n                if (record.blob) {\n                    addFileToHandler(id, record.blob);\n                    fileList.push({id: id, file: record.blob});\n                }\n                else {\n                    uploadData.setStatus(id, qq.status.REJECTED);\n                }\n            });\n\n            // If we are potentially uploading an original file and some scaled versions,\n            // ensure the scaled versions include reference's to the parent's UUID and size\n            // in their associated upload requests.\n            if (originalId !== null) {\n                qq.each(scaledIds, function(idx, scaledId) {\n                    var params = {\n                        qqparentuuid: uploadData.retrieve({id: originalId}).uuid,\n                        qqparentsize: uploadData.retrieve({id: originalId}).size\n                    };\n\n                    // Make sure the UUID for each scaled image is sent with the upload request,\n                    // to be consistent (since we may need to ensure it is sent for the original file as well).\n                    params[uuidParamName] = uploadData.retrieve({id: scaledId}).uuid;\n\n                    uploadData.setParentId(scaledId, originalId);\n                    paramsStore.addReadOnly(scaledId, params);\n                });\n\n                // If any scaled images are tied to this parent image, be SURE we send its UUID as an upload request\n                // parameter as well.\n                if (scaledIds.length) {\n                    (function() {\n                        var param = {};\n                        param[uuidParamName] = uploadData.retrieve({id: originalId}).uuid;\n                        paramsStore.addReadOnly(originalId, param);\n                    }());\n                }\n            }\n        }\n    });\n};\n\nqq.extend(qq.Scaler.prototype, {\n    scaleImage: function(id, specs, api) {\n        \"use strict\";\n\n        if (!qq.supportedFeatures.scaling) {\n            throw new qq.Error(\"Scaling is not supported in this browser!\");\n        }\n\n        var scalingEffort = new qq.Promise(),\n            log = api.log,\n            file = api.getFile(id),\n            uploadData = api.uploadData.retrieve({id: id}),\n            name = uploadData && uploadData.name,\n            uuid = uploadData && uploadData.uuid,\n            scalingOptions = {\n                customResizer: specs.customResizer,\n                sendOriginal: false,\n                orient: specs.orient,\n                defaultType: specs.type || null,\n                defaultQuality: specs.quality,\n                failedToScaleText: \"Unable to scale\",\n                sizes: [{name: \"\", maxSize: specs.maxSize}]\n            },\n            scaler = new qq.Scaler(scalingOptions, log);\n\n        if (!qq.Scaler || !qq.supportedFeatures.imagePreviews || !file) {\n            scalingEffort.failure();\n\n            log(\"Could not generate requested scaled image for \" + id + \".  \" +\n                \"Scaling is either not possible in this browser, or the file could not be located.\", \"error\");\n        }\n        else {\n            (qq.bind(function() {\n                // Assumption: There will never be more than one record\n                var record = scaler.getFileRecords(uuid, name, file)[0];\n\n                if (record && record.blob instanceof qq.BlobProxy) {\n                    record.blob.create().then(scalingEffort.success, scalingEffort.failure);\n                }\n                else {\n                    log(id + \" is not a scalable image!\", \"error\");\n                    scalingEffort.failure();\n                }\n            }, this)());\n        }\n\n        return scalingEffort;\n    },\n\n    // NOTE: We cannot reliably determine at this time if the UA supports a specific MIME type for the target format.\n    // image/jpeg and image/png are the only safe choices at this time.\n    _determineOutputType: function(spec) {\n        \"use strict\";\n\n        var requestedType = spec.requestedType,\n            defaultType = spec.defaultType,\n            referenceType = spec.refType;\n\n        // If a default type and requested type have not been specified, this should be a\n        // JPEG if the original type is a JPEG, otherwise, a PNG.\n        if (!defaultType && !requestedType) {\n            if (referenceType !== \"image/jpeg\") {\n                return \"image/png\";\n            }\n            return referenceType;\n        }\n\n        // A specified default type is used when a requested type is not specified.\n        if (!requestedType) {\n            return defaultType;\n        }\n\n        // If requested type is specified, use it, as long as this recognized type is supported by the current UA\n        if (qq.indexOf(Object.keys(qq.Identify.prototype.PREVIEWABLE_MIME_TYPES), requestedType) >= 0) {\n            if (requestedType === \"image/tiff\") {\n                return qq.supportedFeatures.tiffPreviews ? requestedType : defaultType;\n            }\n\n            return requestedType;\n        }\n\n        return defaultType;\n    },\n\n    // Get a file name for a generated scaled file record, based on the provided scaled image description\n    _getName: function(originalName, scaledVersionProperties) {\n        \"use strict\";\n\n        var startOfExt = originalName.lastIndexOf(\".\"),\n            versionType = scaledVersionProperties.type || \"image/png\",\n            referenceType = scaledVersionProperties.refType,\n            scaledName = \"\",\n            scaledExt = qq.getExtension(originalName),\n            nameAppendage = \"\";\n\n        if (scaledVersionProperties.name && scaledVersionProperties.name.trim().length) {\n            nameAppendage = \" (\" + scaledVersionProperties.name + \")\";\n        }\n\n        if (startOfExt >= 0) {\n            scaledName = originalName.substr(0, startOfExt);\n\n            if (referenceType !== versionType) {\n                scaledExt = versionType.split(\"/\")[1];\n            }\n\n            scaledName += nameAppendage + \".\" + scaledExt;\n        }\n        else {\n            scaledName = originalName + nameAppendage;\n        }\n\n        return scaledName;\n    },\n\n    // We want the smallest scaled file to be uploaded first\n    _getSortedSizes: function(sizes) {\n        \"use strict\";\n\n        sizes = qq.extend([], sizes);\n\n        return sizes.sort(function(a, b) {\n            if (a.maxSize > b.maxSize) {\n                return 1;\n            }\n            if (a.maxSize < b.maxSize) {\n                return -1;\n            }\n            return 0;\n        });\n    },\n\n    _generateScaledImage: function(spec, sourceFile) {\n        \"use strict\";\n\n        var self = this,\n            customResizeFunction = spec.customResizeFunction,\n            log = spec.log,\n            maxSize = spec.maxSize,\n            orient = spec.orient,\n            type = spec.type,\n            quality = spec.quality,\n            failedText = spec.failedText,\n            includeExif = spec.includeExif && sourceFile.type === \"image/jpeg\" && type === \"image/jpeg\",\n            scalingEffort = new qq.Promise(),\n            imageGenerator = new qq.ImageGenerator(log),\n            canvas = document.createElement(\"canvas\");\n\n        log(\"Attempting to generate scaled version for \" + sourceFile.name);\n\n        imageGenerator.generate(sourceFile, canvas, {maxSize: maxSize, orient: orient, customResizeFunction: customResizeFunction}).then(function() {\n            var scaledImageDataUri = canvas.toDataURL(type, quality),\n                signalSuccess = function() {\n                    log(\"Success generating scaled version for \" + sourceFile.name);\n                    var blob = qq.dataUriToBlob(scaledImageDataUri);\n                    scalingEffort.success(blob);\n                };\n\n            if (includeExif) {\n                self._insertExifHeader(sourceFile, scaledImageDataUri, log).then(function(scaledImageDataUriWithExif) {\n                    scaledImageDataUri = scaledImageDataUriWithExif;\n                    signalSuccess();\n                },\n                function() {\n                    log(\"Problem inserting EXIF header into scaled image.  Using scaled image w/out EXIF data.\", \"error\");\n                    signalSuccess();\n                });\n            }\n            else {\n                signalSuccess();\n            }\n        }, function() {\n            log(\"Failed attempt to generate scaled version for \" + sourceFile.name, \"error\");\n            scalingEffort.failure(failedText);\n        });\n\n        return scalingEffort;\n    },\n\n    // Attempt to insert the original image's EXIF header into a scaled version.\n    _insertExifHeader: function(originalImage, scaledImageDataUri, log) {\n        \"use strict\";\n\n        var reader = new FileReader(),\n            insertionEffort = new qq.Promise(),\n            originalImageDataUri = \"\";\n\n        reader.onload = function() {\n            originalImageDataUri = reader.result;\n            insertionEffort.success(qq.ExifRestorer.restore(originalImageDataUri, scaledImageDataUri));\n        };\n\n        reader.onerror = function() {\n            log(\"Problem reading \" + originalImage.name + \" during attempt to transfer EXIF data to scaled version.\", \"error\");\n            insertionEffort.failure();\n        };\n\n        reader.readAsDataURL(originalImage);\n\n        return insertionEffort;\n    },\n\n    _dataUriToBlob: function(dataUri) {\n        \"use strict\";\n\n        var byteString, mimeString, arrayBuffer, intArray;\n\n        // convert base64 to raw binary data held in a string\n        if (dataUri.split(\",\")[0].indexOf(\"base64\") >= 0) {\n            byteString = atob(dataUri.split(\",\")[1]);\n        }\n        else {\n            byteString = decodeURI(dataUri.split(\",\")[1]);\n        }\n\n        // extract the MIME\n        mimeString = dataUri.split(\",\")[0]\n            .split(\":\")[1]\n            .split(\";\")[0];\n\n        // write the bytes of the binary string to an ArrayBuffer\n        arrayBuffer = new ArrayBuffer(byteString.length);\n        intArray = new Uint8Array(arrayBuffer);\n        qq.each(byteString, function(idx, character) {\n            intArray[idx] = character.charCodeAt(0);\n        });\n\n        return this._createBlob(arrayBuffer, mimeString);\n    },\n\n    _createBlob: function(data, mime) {\n        \"use strict\";\n\n        var BlobBuilder = window.BlobBuilder ||\n                window.WebKitBlobBuilder ||\n                window.MozBlobBuilder ||\n                window.MSBlobBuilder,\n            blobBuilder = BlobBuilder && new BlobBuilder();\n\n        if (blobBuilder) {\n            blobBuilder.append(data);\n            return blobBuilder.getBlob(mime);\n        }\n        else {\n            return new Blob([data], {type: mime});\n        }\n    }\n});\n","//Based on MinifyJpeg\n//http://elicon.blog57.fc2.com/blog-entry-206.html\n\nqq.ExifRestorer = (function()\n{\n   \n\tvar ExifRestorer = {};\n\t \n    ExifRestorer.KEY_STR = \"ABCDEFGHIJKLMNOP\" +\n                         \"QRSTUVWXYZabcdef\" +\n                         \"ghijklmnopqrstuv\" +\n                         \"wxyz0123456789+/\" +\n                         \"=\";\n\n    ExifRestorer.encode64 = function(input)\n    {\n        var output = \"\",\n            chr1, chr2, chr3 = \"\",\n            enc1, enc2, enc3, enc4 = \"\",\n            i = 0;\n\n        do {\n            chr1 = input[i++];\n            chr2 = input[i++];\n            chr3 = input[i++];\n\n            enc1 = chr1 >> 2;\n            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);\n            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);\n            enc4 = chr3 & 63;\n\n            if (isNaN(chr2)) {\n               enc3 = enc4 = 64;\n            } else if (isNaN(chr3)) {\n               enc4 = 64;\n            }\n\n            output = output +\n               this.KEY_STR.charAt(enc1) +\n               this.KEY_STR.charAt(enc2) +\n               this.KEY_STR.charAt(enc3) +\n               this.KEY_STR.charAt(enc4);\n            chr1 = chr2 = chr3 = \"\";\n            enc1 = enc2 = enc3 = enc4 = \"\";\n        } while (i < input.length);\n\n        return output;\n    };\n    \n    ExifRestorer.restore = function(origFileBase64, resizedFileBase64)\n    {\n        var expectedBase64Header = \"data:image/jpeg;base64,\";\n\n        if (!origFileBase64.match(expectedBase64Header))\n        {\n        \treturn resizedFileBase64;\n        }       \n        \n        var rawImage = this.decode64(origFileBase64.replace(expectedBase64Header, \"\"));\n        var segments = this.slice2Segments(rawImage);\n                \n        var image = this.exifManipulation(resizedFileBase64, segments);\n        \n        return expectedBase64Header + this.encode64(image);\n        \n    };\n\n\n    ExifRestorer.exifManipulation = function(resizedFileBase64, segments)\n    {\n            var exifArray = this.getExifArray(segments),\n                newImageArray = this.insertExif(resizedFileBase64, exifArray),\n                aBuffer = new Uint8Array(newImageArray);\n\n            return aBuffer;\n    };\n\n\n    ExifRestorer.getExifArray = function(segments)\n    {\n            var seg;\n            for (var x = 0; x < segments.length; x++)\n            {\n                seg = segments[x];\n                if (seg[0] == 255 & seg[1] == 225) //(ff e1)\n                {\n                    return seg;\n                }\n            }\n            return [];\n    };\n\n\n    ExifRestorer.insertExif = function(resizedFileBase64, exifArray)\n    {\n            var imageData = resizedFileBase64.replace(\"data:image/jpeg;base64,\", \"\"),\n                buf = this.decode64(imageData),\n                separatePoint = buf.indexOf(255,3),\n                mae = buf.slice(0, separatePoint),\n                ato = buf.slice(separatePoint),\n                array = mae;\n\n            array = array.concat(exifArray);\n            array = array.concat(ato);\n           return array;\n    };\n\n\n    \n    ExifRestorer.slice2Segments = function(rawImageArray)\n    {\n        var head = 0,\n            segments = [];\n\n        while (1)\n        {\n            if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 218){break;}\n            if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 216)\n            {\n                head += 2;\n            }\n            else\n            {\n                var length = rawImageArray[head + 2] * 256 + rawImageArray[head + 3],\n                    endPoint = head + length + 2,\n                    seg = rawImageArray.slice(head, endPoint);\n                segments.push(seg);\n                head = endPoint;\n            }\n            if (head > rawImageArray.length){break;}\n        }\n\n        return segments;\n    };\n\n\n    \n    ExifRestorer.decode64 = function(input) \n    {\n        var output = \"\",\n            chr1, chr2, chr3 = \"\",\n            enc1, enc2, enc3, enc4 = \"\",\n            i = 0,\n            buf = [];\n\n        // remove all characters that are not A-Z, a-z, 0-9, +, /, or =\n        var base64test = /[^A-Za-z0-9\\+\\/\\=]/g;\n        if (base64test.exec(input)) {\n            throw new Error(\"There were invalid base64 characters in the input text.  \" +\n                \"Valid base64 characters are A-Z, a-z, 0-9, '+', '/',and '='\");\n        }\n        input = input.replace(/[^A-Za-z0-9\\+\\/\\=]/g, \"\");\n\n        do {\n            enc1 = this.KEY_STR.indexOf(input.charAt(i++));\n            enc2 = this.KEY_STR.indexOf(input.charAt(i++));\n            enc3 = this.KEY_STR.indexOf(input.charAt(i++));\n            enc4 = this.KEY_STR.indexOf(input.charAt(i++));\n\n            chr1 = (enc1 << 2) | (enc2 >> 4);\n            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);\n            chr3 = ((enc3 & 3) << 6) | enc4;\n\n            buf.push(chr1);\n\n            if (enc3 != 64) {\n               buf.push(chr2);\n            }\n            if (enc4 != 64) {\n               buf.push(chr3);\n            }\n\n            chr1 = chr2 = chr3 = \"\";\n            enc1 = enc2 = enc3 = enc4 = \"\";\n\n        } while (i < input.length);\n\n        return buf;\n    };\n\n    \n    return ExifRestorer;\n})();\n","/* globals qq */\n/**\n * Keeps a running tally of total upload progress for a batch of files.\n *\n * @param callback Invoked when total progress changes, passing calculated total loaded & total size values.\n * @param getSize Function that returns the size of a file given its ID\n * @constructor\n */\nqq.TotalProgress = function(callback, getSize) {\n    \"use strict\";\n\n    var perFileProgress = {},\n        totalLoaded = 0,\n        totalSize = 0,\n\n        lastLoadedSent = -1,\n        lastTotalSent = -1,\n        callbackProxy = function(loaded, total) {\n            if (loaded !== lastLoadedSent || total !== lastTotalSent) {\n                callback(loaded, total);\n            }\n\n            lastLoadedSent = loaded;\n            lastTotalSent = total;\n        },\n\n        /**\n         * @param failed Array of file IDs that have failed\n         * @param retryable Array of file IDs that are retryable\n         * @returns true if none of the failed files are eligible for retry\n         */\n        noRetryableFiles = function(failed, retryable) {\n            var none = true;\n\n            qq.each(failed, function(idx, failedId) {\n                if (qq.indexOf(retryable, failedId) >= 0) {\n                    none = false;\n                    return false;\n                }\n            });\n\n            return none;\n        },\n\n        onCancel = function(id) {\n            updateTotalProgress(id, -1, -1);\n            delete perFileProgress[id];\n        },\n\n        onAllComplete = function(successful, failed, retryable) {\n            if (failed.length === 0 || noRetryableFiles(failed, retryable)) {\n                callbackProxy(totalSize, totalSize);\n                this.reset();\n            }\n        },\n\n        onNew = function(id) {\n            var size = getSize(id);\n\n            // We might not know the size yet, such as for blob proxies\n            if (size > 0) {\n                updateTotalProgress(id, 0, size);\n                perFileProgress[id] = {loaded: 0, total: size};\n            }\n        },\n\n        /**\n         * Invokes the callback with the current total progress of all files in the batch.  Called whenever it may\n         * be appropriate to re-calculate and disseminate this data.\n         *\n         * @param id ID of a file that has changed in some important way\n         * @param newLoaded New loaded value for this file.  -1 if this value should no longer be part of calculations\n         * @param newTotal New total size of the file.  -1 if this value should no longer be part of calculations\n         */\n        updateTotalProgress = function(id, newLoaded, newTotal) {\n            var oldLoaded = perFileProgress[id] ? perFileProgress[id].loaded : 0,\n                oldTotal = perFileProgress[id] ? perFileProgress[id].total : 0;\n\n            if (newLoaded === -1 && newTotal === -1) {\n                totalLoaded -= oldLoaded;\n                totalSize -= oldTotal;\n            }\n            else {\n                if (newLoaded) {\n                    totalLoaded += newLoaded - oldLoaded;\n                }\n                if (newTotal) {\n                    totalSize += newTotal - oldTotal;\n                }\n            }\n\n            callbackProxy(totalLoaded, totalSize);\n        };\n\n    qq.extend(this, {\n        // Called when a batch of files has completed uploading.\n        onAllComplete: onAllComplete,\n\n        // Called when the status of a file has changed.\n        onStatusChange: function(id, oldStatus, newStatus) {\n            if (newStatus === qq.status.CANCELED || newStatus === qq.status.REJECTED) {\n                onCancel(id);\n            }\n            else if (newStatus === qq.status.SUBMITTING) {\n                onNew(id);\n            }\n        },\n\n        // Called whenever the upload progress of an individual file has changed.\n        onIndividualProgress: function(id, loaded, total) {\n            updateTotalProgress(id, loaded, total);\n            perFileProgress[id] = {loaded: loaded, total: total};\n        },\n\n        // Called whenever the total size of a file has changed, such as when the size of a generated blob is known.\n        onNewSize: function(id) {\n            onNew(id);\n        },\n\n        reset: function() {\n            perFileProgress = {};\n            totalLoaded = 0;\n            totalSize = 0;\n        }\n    });\n};\n","/*globals qq*/\nqq.PasteSupport = function(o) {\n    \"use strict\";\n\n    var options, detachPasteHandler;\n\n    options = {\n        targetElement: null,\n        callbacks: {\n            log: function(message, level) {},\n            pasteReceived: function(blob) {}\n        }\n    };\n\n    function isImage(item) {\n        return item.type &&\n            item.type.indexOf(\"image/\") === 0;\n    }\n\n    function registerPasteHandler() {\n        detachPasteHandler = qq(options.targetElement).attach(\"paste\", function(event) {\n            var clipboardData = event.clipboardData;\n\n            if (clipboardData) {\n                qq.each(clipboardData.items, function(idx, item) {\n                    if (isImage(item)) {\n                        var blob = item.getAsFile();\n                        options.callbacks.pasteReceived(blob);\n                    }\n                });\n            }\n        });\n    }\n\n    function unregisterPasteHandler() {\n        if (detachPasteHandler) {\n            detachPasteHandler();\n        }\n    }\n\n    qq.extend(options, o);\n    registerPasteHandler();\n\n    qq.extend(this, {\n        reset: function() {\n            unregisterPasteHandler();\n        }\n    });\n};\n","/* globals qq */\n/**\n * Module that handles support for existing forms.\n *\n * @param options Options passed from the integrator-supplied options related to form support.\n * @param startUpload Callback to invoke when files \"stored\" should be uploaded.\n * @param log Proxy for the logger\n * @constructor\n */\nqq.FormSupport = function(options, startUpload, log) {\n    \"use strict\";\n    var self  = this,\n        interceptSubmit = options.interceptSubmit,\n        formEl = options.element,\n        autoUpload = options.autoUpload;\n\n    // Available on the public API associated with this module.\n    qq.extend(this, {\n        // To be used by the caller to determine if the endpoint will be determined by some processing\n        // that occurs in this module, such as if the form has an action attribute.\n        // Ignore if `attachToForm === false`.\n        newEndpoint: null,\n\n        // To be used by the caller to determine if auto uploading should be allowed.\n        // Ignore if `attachToForm === false`.\n        newAutoUpload: autoUpload,\n\n        // true if a form was detected and is being tracked by this module\n        attachedToForm: false,\n\n        // Returns an object with names and values for all valid form elements associated with the attached form.\n        getFormInputsAsObject: function() {\n            /* jshint eqnull:true */\n            if (formEl == null) {\n                return null;\n            }\n\n            return self._form2Obj(formEl);\n        }\n    });\n\n    // If the form contains an action attribute, this should be the new upload endpoint.\n    function determineNewEndpoint(formEl) {\n        if (formEl.getAttribute(\"action\")) {\n            self.newEndpoint = formEl.getAttribute(\"action\");\n        }\n    }\n\n    // Return true only if the form is valid, or if we cannot make this determination.\n    // If the form is invalid, ensure invalid field(s) are highlighted in the UI.\n    function validateForm(formEl, nativeSubmit) {\n        if (formEl.checkValidity && !formEl.checkValidity()) {\n            log(\"Form did not pass validation checks - will not upload.\", \"error\");\n            nativeSubmit();\n        }\n        else {\n            return true;\n        }\n    }\n\n    // Intercept form submit attempts, unless the integrator has told us not to do this.\n    function maybeUploadOnSubmit(formEl) {\n        var nativeSubmit = formEl.submit;\n\n        // Intercept and squelch submit events.\n        qq(formEl).attach(\"submit\", function(event) {\n            event = event || window.event;\n\n            if (event.preventDefault) {\n                event.preventDefault();\n            }\n            else {\n                event.returnValue = false;\n            }\n\n            validateForm(formEl, nativeSubmit) && startUpload();\n        });\n\n        // The form's `submit()` function may be called instead (i.e. via jQuery.submit()).\n        // Intercept that too.\n        formEl.submit = function() {\n            validateForm(formEl, nativeSubmit) && startUpload();\n        };\n    }\n\n    // If the element value passed from the uploader is a string, assume it is an element ID - select it.\n    // The rest of the code in this module depends on this being an HTMLElement.\n    function determineFormEl(formEl) {\n        if (formEl) {\n            if (qq.isString(formEl)) {\n                formEl = document.getElementById(formEl);\n            }\n\n            if (formEl) {\n                log(\"Attaching to form element.\");\n                determineNewEndpoint(formEl);\n                interceptSubmit && maybeUploadOnSubmit(formEl);\n            }\n        }\n\n        return formEl;\n    }\n\n    formEl = determineFormEl(formEl);\n    this.attachedToForm = !!formEl;\n};\n\nqq.extend(qq.FormSupport.prototype, {\n    // Converts all relevant form fields to key/value pairs.  This is meant to mimic the data a browser will\n    // construct from a given form when the form is submitted.\n    _form2Obj: function(form) {\n        \"use strict\";\n        var obj = {},\n            notIrrelevantType = function(type) {\n                var irrelevantTypes = [\n                    \"button\",\n                    \"image\",\n                    \"reset\",\n                    \"submit\"\n                ];\n\n                return qq.indexOf(irrelevantTypes, type.toLowerCase()) < 0;\n            },\n            radioOrCheckbox = function(type) {\n                return qq.indexOf([\"checkbox\", \"radio\"], type.toLowerCase()) >= 0;\n            },\n            ignoreValue = function(el) {\n                if (radioOrCheckbox(el.type) && !el.checked) {\n                    return true;\n                }\n\n                return el.disabled && el.type.toLowerCase() !== \"hidden\";\n            },\n            selectValue = function(select) {\n                var value = null;\n\n                qq.each(qq(select).children(), function(idx, child) {\n                    if (child.tagName.toLowerCase() === \"option\" && child.selected) {\n                        value = child.value;\n                        return false;\n                    }\n                });\n\n                return value;\n            };\n\n        qq.each(form.elements, function(idx, el) {\n            if ((qq.isInput(el, true) || el.tagName.toLowerCase() === \"textarea\") &&\n                notIrrelevantType(el.type) &&\n                !ignoreValue(el)) {\n\n                obj[el.name] = el.value;\n            }\n            else if (el.tagName.toLowerCase() === \"select\" && !ignoreValue(el)) {\n                var value = selectValue(el);\n\n                if (value !== null) {\n                    obj[el.name] = value;\n                }\n            }\n        });\n\n        return obj;\n    }\n});\n","/*globals qq*/\n/**\n * Upload handler used that assumes the current user agent does not have any support for the\n * File API, and, therefore, makes use of iframes and forms to submit the files directly to\n * a generic server.\n *\n * @param options Options passed from the base handler\n * @param proxy Callbacks & methods used to query for or push out data/changes\n */\nqq.traditional = qq.traditional || {};\nqq.traditional.FormUploadHandler = function(options, proxy) {\n    \"use strict\";\n\n    var handler = this,\n        getName = proxy.getName,\n        getUuid = proxy.getUuid,\n        log = proxy.log;\n\n    /**\n     * Returns json object received by iframe from server.\n     */\n    function getIframeContentJson(id, iframe) {\n        /*jshint evil: true*/\n\n        var response, doc, innerHtml;\n\n        //IE may throw an \"access is denied\" error when attempting to access contentDocument on the iframe in some cases\n        try {\n            // iframe.contentWindow.document - for IE<7\n            doc = iframe.contentDocument || iframe.contentWindow.document;\n            innerHtml = doc.body.innerHTML;\n\n            log(\"converting iframe's innerHTML to JSON\");\n            log(\"innerHTML = \" + innerHtml);\n            //plain text response may be wrapped in <pre> tag\n            if (innerHtml && innerHtml.match(/^<pre/i)) {\n                innerHtml = doc.body.firstChild.firstChild.nodeValue;\n            }\n\n            response = handler._parseJsonResponse(innerHtml);\n        }\n        catch (error) {\n            log(\"Error when attempting to parse form upload response (\" + error.message + \")\", \"error\");\n            response = {success: false};\n        }\n\n        return response;\n    }\n\n    /**\n     * Creates form, that will be submitted to iframe\n     */\n    function createForm(id, iframe) {\n        var params = options.paramsStore.get(id),\n            method = options.method.toLowerCase() === \"get\" ? \"GET\" : \"POST\",\n            endpoint = options.endpointStore.get(id),\n            name = getName(id);\n\n        params[options.uuidName] = getUuid(id);\n        params[options.filenameParam] = name;\n\n        return handler._initFormForUpload({\n            method: method,\n            endpoint: endpoint,\n            params: params,\n            paramsInBody: options.paramsInBody,\n            targetName: iframe.name\n        });\n    }\n\n    this.uploadFile = function(id) {\n        var input = handler.getInput(id),\n            iframe = handler._createIframe(id),\n            promise = new qq.Promise(),\n            form;\n\n        form = createForm(id, iframe);\n        form.appendChild(input);\n\n        handler._attachLoadEvent(iframe, function(responseFromMessage) {\n            log(\"iframe loaded\");\n\n            var response = responseFromMessage ? responseFromMessage : getIframeContentJson(id, iframe);\n\n            handler._detachLoadEvent(id);\n\n            //we can't remove an iframe if the iframe doesn't belong to the same domain\n            if (!options.cors.expected) {\n                qq(iframe).remove();\n            }\n\n            if (response.success) {\n                promise.success(response);\n            }\n            else {\n                promise.failure(response);\n            }\n        });\n\n        log(\"Sending upload request for \" + id);\n        form.submit();\n        qq(form).remove();\n\n        return promise;\n    };\n\n    qq.extend(this, new qq.FormUploadHandler({\n        options: {\n            isCors: options.cors.expected,\n            inputName: options.inputName\n        },\n\n        proxy: {\n            onCancel: options.onCancel,\n            getName: getName,\n            getUuid: getUuid,\n            log: log\n        }\n    }));\n};\n","/*globals qq*/\n/**\n * Upload handler used to upload to traditional endpoints.  It depends on File API support, and, therefore,\n * makes use of `XMLHttpRequest` level 2 to upload `File`s and `Blob`s to a generic server.\n *\n * @param spec Options passed from the base handler\n * @param proxy Callbacks & methods used to query for or push out data/changes\n */\nqq.traditional = qq.traditional || {};\nqq.traditional.XhrUploadHandler = function(spec, proxy) {\n    \"use strict\";\n\n    var handler = this,\n        getName = proxy.getName,\n        getSize = proxy.getSize,\n        getUuid = proxy.getUuid,\n        log = proxy.log,\n        multipart = spec.forceMultipart || spec.paramsInBody,\n\n        addChunkingSpecificParams = function(id, params, chunkData) {\n            var size = getSize(id),\n                name = getName(id);\n\n            if (!spec.omitDefaultParams) {\n                params[spec.chunking.paramNames.partIndex] = chunkData.part;\n                params[spec.chunking.paramNames.partByteOffset] = chunkData.start;\n                params[spec.chunking.paramNames.chunkSize] = chunkData.size;\n                params[spec.chunking.paramNames.totalParts] = chunkData.count;\n                params[spec.totalFileSizeName] = size;\n            }\n\n            /**\n             * When a Blob is sent in a multipart request, the filename value in the content-disposition header is either \"blob\"\n             * or an empty string.  So, we will need to include the actual file name as a param in this case.\n             */\n            if (multipart && !spec.omitDefaultParams) {\n                params[spec.filenameParam] = name;\n            }\n        },\n\n        allChunksDoneRequester = new qq.traditional.AllChunksDoneAjaxRequester({\n            cors: spec.cors,\n            endpoint: spec.chunking.success.endpoint,\n            headers: spec.chunking.success.headers,\n            jsonPayload: spec.chunking.success.jsonPayload,\n            log: log,\n            method: spec.chunking.success.method,\n            params: spec.chunking.success.params\n        }),\n\n        createReadyStateChangedHandler = function(id, xhr) {\n            var promise = new qq.Promise();\n\n            xhr.onreadystatechange = function() {\n                if (xhr.readyState === 4) {\n                    var result = onUploadOrChunkComplete(id, xhr);\n\n                    if (result.success) {\n                        promise.success(result.response, xhr);\n                    }\n                    else {\n                        promise.failure(result.response, xhr);\n                    }\n                }\n            };\n\n            return promise;\n        },\n\n        getChunksCompleteParams = function(id) {\n            var params = spec.paramsStore.get(id),\n                name = getName(id),\n                size = getSize(id);\n\n            params[spec.uuidName] = getUuid(id);\n            params[spec.filenameParam] = name;\n            params[spec.totalFileSizeName] = size;\n            params[spec.chunking.paramNames.totalParts] = handler._getTotalChunks(id);\n\n            return params;\n        },\n\n        isErrorUploadResponse = function(xhr, response) {\n            return qq.indexOf([200, 201, 202, 203, 204], xhr.status) < 0 ||\n                (spec.requireSuccessJson && !response.success) ||\n                response.reset;\n        },\n\n        onUploadOrChunkComplete = function(id, xhr) {\n            var response;\n\n            log(\"xhr - server response received for \" + id);\n            log(\"responseText = \" + xhr.responseText);\n\n            response = parseResponse(true, xhr);\n\n            return {\n                success: !isErrorUploadResponse(xhr, response),\n                response: response\n            };\n        },\n\n        // If this is an upload response, we require a JSON payload, otherwise, it is optional.\n        parseResponse = function(upload, xhr) {\n            var response = {};\n\n            try {\n                log(qq.format(\"Received response status {} with body: {}\", xhr.status, xhr.responseText));\n                response = qq.parseJson(xhr.responseText);\n            }\n            catch (error) {\n                upload && spec.requireSuccessJson && log(\"Error when attempting to parse xhr response text (\" + error.message + \")\", \"error\");\n            }\n\n            return response;\n        },\n\n        sendChunksCompleteRequest = function(id) {\n            var promise = new qq.Promise();\n\n            allChunksDoneRequester.complete(\n                    id,\n                    handler._createXhr(id),\n                    getChunksCompleteParams(id),\n                    spec.customHeaders.get(id)\n                )\n                .then(function(xhr) {\n                    promise.success(parseResponse(false, xhr), xhr);\n                }, function(xhr) {\n                    promise.failure(parseResponse(false, xhr), xhr);\n                });\n\n            return promise;\n        },\n\n        setParamsAndGetEntityToSend = function(entityToSendParams) {\n            var fileOrBlob = entityToSendParams.fileOrBlob;\n            var id = entityToSendParams.id;\n            var xhr = entityToSendParams.xhr;\n            var xhrOverrides = entityToSendParams.xhrOverrides || {};\n            var customParams = entityToSendParams.customParams || {};\n            var defaultParams = entityToSendParams.params || {};\n            var xhrOverrideParams = xhrOverrides.params || {};\n            var params;\n\n            var formData = multipart ? new FormData() : null,\n                method = xhrOverrides.method || spec.method,\n                endpoint = xhrOverrides.endpoint || spec.endpointStore.get(id),\n                name = getName(id),\n                size = getSize(id);\n\n            if (spec.omitDefaultParams) {\n                params = qq.extend({}, customParams);\n                qq.extend(params, xhrOverrideParams);\n            }\n            else {\n                params = qq.extend({}, customParams);\n                qq.extend(params, xhrOverrideParams);\n                qq.extend(params, defaultParams);\n\n                params[spec.uuidName] = getUuid(id);\n                params[spec.filenameParam] = name;\n\n                if (multipart) {\n                    params[spec.totalFileSizeName] = size;\n                }\n                else if (!spec.paramsInBody) {\n                    params[spec.inputName] = name;\n                }\n            }\n\n            //build query string\n            if (!spec.paramsInBody) {\n                endpoint = qq.obj2url(params, endpoint);\n            }\n\n            xhr.open(method, endpoint, true);\n\n            if (spec.cors.expected && spec.cors.sendCredentials) {\n                xhr.withCredentials = true;\n            }\n\n            if (multipart) {\n                if (spec.paramsInBody) {\n                    qq.obj2FormData(params, formData);\n                }\n\n                formData.append(spec.inputName, fileOrBlob);\n                return formData;\n            }\n\n            return fileOrBlob;\n        },\n\n        setUploadHeaders = function(headersOptions) {\n            var headerOverrides = headersOptions.headerOverrides;\n            var id = headersOptions.id;\n            var xhr = headersOptions.xhr;\n\n            if (headerOverrides) {\n                qq.each(headerOverrides, function(headerName, headerValue) {\n                    xhr.setRequestHeader(headerName, headerValue);\n                });\n            }\n            else {\n                var extraHeaders = spec.customHeaders.get(id),\n                    fileOrBlob = handler.getFile(id);\n\n                xhr.setRequestHeader(\"Accept\", \"application/json\");\n                xhr.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\n                xhr.setRequestHeader(\"Cache-Control\", \"no-cache\");\n\n                if (!multipart) {\n                    xhr.setRequestHeader(\"Content-Type\", \"application/octet-stream\");\n                    //NOTE: return mime type in xhr works on chrome 16.0.9 firefox 11.0a2\n                    xhr.setRequestHeader(\"X-Mime-Type\", fileOrBlob.type);\n                }\n\n                qq.each(extraHeaders, function(name, val) {\n                    xhr.setRequestHeader(name, val);\n                });\n            }\n        };\n\n    qq.extend(this, {\n        uploadChunk: function(uploadChunkParams) {\n            var id = uploadChunkParams.id;\n            var chunkIdx = uploadChunkParams.chunkIdx;\n            var overrides = uploadChunkParams.overrides || {};\n            var resuming = uploadChunkParams.resuming;\n\n            var chunkData = handler._getChunkData(id, chunkIdx),\n                xhr = handler._createXhr(id, chunkIdx),\n                promise, toSend, customParams, params = {};\n\n            promise = createReadyStateChangedHandler(id, xhr);\n            handler._registerProgressHandler(id, chunkIdx, chunkData.size);\n            customParams = spec.paramsStore.get(id);\n            addChunkingSpecificParams(id, params, chunkData);\n\n            if (resuming) {\n                params[spec.resume.paramNames.resuming] = true;\n            }\n\n            toSend = setParamsAndGetEntityToSend({\n                fileOrBlob: chunkData.blob,\n                id: id,\n                customParams: customParams,\n                params: params,\n                xhr: xhr,\n                xhrOverrides: overrides\n            });\n\n            setUploadHeaders({\n                headerOverrides: overrides.headers,\n                id: id,\n                xhr: xhr\n            });\n\n            xhr.send(toSend);\n\n            return promise;\n        },\n\n        uploadFile: function(id) {\n            var fileOrBlob = handler.getFile(id),\n                promise, xhr, customParams, toSend;\n\n            xhr = handler._createXhr(id);\n            handler._registerProgressHandler(id);\n            promise = createReadyStateChangedHandler(id, xhr);\n            customParams = spec.paramsStore.get(id);\n\n            toSend = setParamsAndGetEntityToSend({\n                fileOrBlob: fileOrBlob,\n                id: id,\n                customParams: customParams,\n                xhr: xhr\n            });\n\n            setUploadHeaders({\n                id: id,\n                xhr: xhr\n            });\n\n            xhr.send(toSend);\n\n            return promise;\n        }\n    });\n\n    qq.extend(this, new qq.XhrUploadHandler({\n        options: qq.extend({namespace: \"traditional\"}, spec),\n        proxy: qq.extend({getEndpoint: spec.endpointStore.get}, proxy)\n    }));\n\n    qq.override(this, function(super_) {\n        return {\n            finalizeChunks: function(id) {\n                proxy.onFinalizing(id);\n\n                if (spec.chunking.success.endpoint) {\n                    return sendChunksCompleteRequest(id);\n                }\n                else {\n                    return super_.finalizeChunks(id, qq.bind(parseResponse, this, true));\n                }\n            }\n        };\n    });\n};\n","/*globals qq*/\n/**\n * Ajax requester used to send a POST to a traditional endpoint once all chunks for a specific file have uploaded\n * successfully.\n *\n * @param o Options from the caller - will override the defaults.\n * @constructor\n */\nqq.traditional.AllChunksDoneAjaxRequester = function(o) {\n    \"use strict\";\n\n    var requester,\n        options = {\n            cors: {\n                allowXdr: false,\n                expected: false,\n                sendCredentials: false\n            },\n            endpoint: null,\n            log: function(str, level) {},\n            method: \"POST\"\n        },\n        promises = {},\n        endpointHandler = {\n            get: function(id) {\n                if (qq.isFunction(options.endpoint)) {\n                    return options.endpoint(id);\n                }\n\n                return options.endpoint;\n            }\n        };\n\n    qq.extend(options, o);\n\n    requester = qq.extend(this, new qq.AjaxRequester({\n        acceptHeader: \"application/json\",\n        contentType: options.jsonPayload ? \"application/json\" : \"application/x-www-form-urlencoded\",\n        validMethods: [options.method],\n        method: options.method,\n        endpointStore: endpointHandler,\n        allowXRequestedWithAndCacheControl: false,\n        cors: options.cors,\n        log: options.log,\n        onComplete: function(id, xhr, isError) {\n            var promise = promises[id];\n\n            delete promises[id];\n\n            if (isError) {\n                promise.failure(xhr);\n            }\n            else {\n                promise.success(xhr);\n            }\n        }\n    }));\n\n    qq.extend(this, {\n        complete: function(id, xhr, params, headers) {\n            var promise = new qq.Promise();\n\n            options.log(\"Submitting All Chunks Done request for \" + id);\n\n            promises[id] = promise;\n\n            requester.initTransport(id)\n                .withParams(options.params(id) || params)\n                .withHeaders(options.headers(id) || headers)\n                .send(xhr);\n\n            return promise;\n        }\n    });\n};\n"]}