diff --git a/.gitmodules b/.gitmodules
index a4579b45..8b137891 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +1 @@
 
-[submodule "node_modules/react-s3-fineuploader"]
-	path = node_modules/react-s3-fineuploader
-	url = https://bitbucket.org/ascribe/react-s3-fineuploader.git
diff --git a/js/components/ascribe_uploader/file_drag_and_drop.js b/js/components/ascribe_uploader/file_drag_and_drop.js
new file mode 100644
index 00000000..0d57bb1c
--- /dev/null
+++ b/js/components/ascribe_uploader/file_drag_and_drop.js
@@ -0,0 +1,122 @@
+import React from 'react';
+import FileDragAndDropPreviewIterator from './file_drag_and_drop_preview_iterator';
+
+
+// Taken from: https://github.com/fedosejev/react-file-drag-and-drop
+var FileDragAndDrop = React.createClass({
+    propTypes: {
+        onDragStart: React.PropTypes.func,
+        onDrop: React.PropTypes.func.isRequired,
+        onDragEnter: React.PropTypes.func,
+        onLeave: React.PropTypes.func,
+        onDragOver: React.PropTypes.func,
+        onDragEnd: React.PropTypes.func,
+        filesToUpload: React.PropTypes.array,
+        handleDeleteFile: React.PropTypes.func
+    },
+
+    handleDragStart(event) {
+        if (typeof this.props.onDragStart === 'function') {
+            this.props.onDragStart(event);
+        }
+    },
+
+    handleDrag(event) {
+        if (typeof this.props.onDrag === 'function') {
+            this.props.onDrag(event);
+        }
+    },
+
+    handleDragEnd(event) {
+        if (typeof this.props.onDragEnd === 'function') {
+          this.props.onDragEnd(event);
+        }
+    },
+
+    handleDragEnter(event) {
+        if (typeof this.props.onDragEnter === 'function') {
+            this.props.onDragEnter(event);
+        }
+    },
+
+    handleDragLeave(event) {
+        if (typeof this.props.onDragLeave === 'function') {
+            this.props.onDragLeave(event);
+        }
+    },
+
+    handleDragOver(event) {
+        event.preventDefault();
+
+        if (typeof this.props.onDragOver === 'function') {
+            this.props.onDragOver(event);
+        }
+    },
+
+
+    handleDrop(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        let files;
+
+        // handle Drag and Drop
+        if(event.dataTransfer && event.dataTransfer.files.length > 0) {
+            files = event.dataTransfer.files;
+        } else if(event.target.files) { // handle input type file
+            files = event.target.files;
+        }
+
+        if(typeof this.props.onDrop === 'function' && files) {
+          this.props.onDrop(files);
+        }
+
+    },
+
+    handleDeleteFile(fileId) {
+        // input's value is not change the second time someone
+        // inputs the same file again, therefore we need to reset its value
+        this.refs.fileinput.getDOMNode().value = '';
+        this.props.handleDeleteFile(fileId);
+    },
+
+    handleOnClick() {
+        // Simulate click on hidden file input
+        var event = document.createEvent("HTMLEvents");
+        event.initEvent("click", false, true);
+        this.refs.fileinput.getDOMNode().dispatchEvent(event);
+    },
+
+    render: function () {
+        let hasFiles = this.props.filesToUpload.length > 0;
+
+        return (
+            <div
+                className={hasFiles ? 'file-drag-and-drop has-files' : 'file-drag-and-drop' }
+                onClick={this.handleOnClick}
+                onDragStart={this.handleDragStart}
+                onDrag={this.handleDrop}
+                onDragEnter={this.handleDragEnter}
+                onDragLeave={this.handleDragLeave}
+                onDragOver={this.handleDragOver}
+                onDrop={this.handleDrop}
+                onDragEnd={this.handleDragEnd}>
+                    {hasFiles ? null : <span>Click or drag to add files</span>}
+                    <FileDragAndDropPreviewIterator 
+                        files={this.props.filesToUpload}
+                        handleDeleteFile={this.handleDeleteFile}/>
+                    <input
+                        multiple
+                        ref="fileinput"
+                        type="file" 
+                        style={{
+                            display: 'none',
+                            height:0,
+                            width:0
+                        }}
+                        onChange={this.handleDrop} />
+            </div>
+      );
+    }
+});
+
+module.exports = FileDragAndDrop;
\ No newline at end of file
diff --git a/js/components/ascribe_uploader/file_drag_and_drop_preview.js b/js/components/ascribe_uploader/file_drag_and_drop_preview.js
new file mode 100644
index 00000000..4f3980c3
--- /dev/null
+++ b/js/components/ascribe_uploader/file_drag_and_drop_preview.js
@@ -0,0 +1,52 @@
+import React from 'react';
+
+import FileDragAndDropPreviewImage from './file_drag_and_drop_preview_image';
+import FileDragAndDropPreviewOther from './file_drag_and_drop_preview_other';
+
+
+let FileDragAndDropPreview = React.createClass({
+
+    propsTypes: {
+        file: React.PropTypes.shape({
+            url: React.PropTypes.string,
+            type: React.PropTypes.string
+        }).isRequired,
+        handleDeleteFile: React.PropTypes.func
+    },
+
+    handleDeleteFile(event) {
+        event.preventDefault();
+        event.stopPropagation();
+
+        // handleDeleteFile is optional, so if its not submitted,
+        // don't run it
+        if(this.props.handleDeleteFile) {
+            this.props.handleDeleteFile(this.props.file.id);
+        }
+    },
+
+    render() {
+        let previewElement;
+
+        // Decide wether an image or a placeholder picture should be displayed
+        if(this.props.file.type.split('/')[0] === 'image') {
+            previewElement = (<FileDragAndDropPreviewImage 
+                    progress={this.props.file.progress} 
+                    url={this.props.file.url}/>);
+        } else {
+            previewElement = (<FileDragAndDropPreviewOther 
+                    progress={this.props.file.progress} 
+                    type={this.props.file.type.split('/')[1]}/>);
+        }
+
+        return (
+            <div 
+                className="file-drag-and-drop-position" 
+                onClick={this.handleDeleteFile}>
+                {previewElement}
+            </div>
+        );
+    }
+});
+
+export default FileDragAndDropPreview;
\ No newline at end of file
diff --git a/js/components/ascribe_uploader/file_drag_and_drop_preview_image.js b/js/components/ascribe_uploader/file_drag_and_drop_preview_image.js
new file mode 100644
index 00000000..53790191
--- /dev/null
+++ b/js/components/ascribe_uploader/file_drag_and_drop_preview_image.js
@@ -0,0 +1,26 @@
+import React from 'react';
+import ProgressBar from 'react-progressbar';
+
+let FileDragAndDropPreviewImage = React.createClass({
+    propTypes: {
+        progress: React.PropTypes.number,
+        url: React.PropTypes.string
+    },
+
+    render() {
+        let imageStyle = {
+            backgroundImage: 'url("' + this.props.url + '")',
+            backgroundSize: 'cover'
+        };
+
+        return (
+            <div
+                className="file-drag-and-drop-preview-image"
+                style={imageStyle}>
+                    <ProgressBar completed={this.props.progress} color="black"/>
+            </div>
+        );
+    }
+});
+
+export default FileDragAndDropPreviewImage;
\ No newline at end of file
diff --git a/js/components/ascribe_uploader/file_drag_and_drop_preview_iterator.js b/js/components/ascribe_uploader/file_drag_and_drop_preview_iterator.js
new file mode 100644
index 00000000..47168793
--- /dev/null
+++ b/js/components/ascribe_uploader/file_drag_and_drop_preview_iterator.js
@@ -0,0 +1,31 @@
+import React from 'react';
+
+import FileDragAndDropPreview from './file_drag_and_drop_preview';
+
+let FileDragAndDropPreviewIterator = React.createClass({
+    propTypes: {
+        files: React.PropTypes.array,
+        handleDeleteFile: React.PropTypes.func
+    },
+
+    render() {
+        if(this.props.files) {
+            return (
+                <div>
+                    {this.props.files.map((file, i) => {
+                        return (
+                            <FileDragAndDropPreview 
+                                key={i}
+                                file={file}
+                                handleDeleteFile={this.props.handleDeleteFile}/>
+                        );
+                    })}
+                </div>
+            );
+        } else {
+            return null;
+        }
+    }
+});
+
+export default FileDragAndDropPreviewIterator;
\ No newline at end of file
diff --git a/js/components/ascribe_uploader/file_drag_and_drop_preview_other.js b/js/components/ascribe_uploader/file_drag_and_drop_preview_other.js
new file mode 100644
index 00000000..18f4031c
--- /dev/null
+++ b/js/components/ascribe_uploader/file_drag_and_drop_preview_other.js
@@ -0,0 +1,25 @@
+import React from 'react';
+import ProgressBar from 'react-progressbar';
+
+let FileDragAndDropPreviewOther = React.createClass({
+    propTypes: {
+        type: React.PropTypes.string,
+        progress: React.PropTypes.number
+    },
+
+    render() {
+        return(
+            <div 
+                className="file-drag-and-drop-preview">
+                <ProgressBar completed={this.props.progress} color="black"/>
+                <div className="file-drag-and-drop-preview-table-wrapper">
+                    <div className="file-drag-and-drop-preview-other">
+                        <span>{'.' + this.props.type}</span>
+                    </div>
+                </div>
+            </div>
+        );
+    }
+});
+
+export default FileDragAndDropPreviewOther;
\ No newline at end of file
diff --git a/js/components/ascribe_uploader/react_s3_fine_uploader.js b/js/components/ascribe_uploader/react_s3_fine_uploader.js
new file mode 100644
index 00000000..1011d763
--- /dev/null
+++ b/js/components/ascribe_uploader/react_s3_fine_uploader.js
@@ -0,0 +1,269 @@
+'use strict';
+
+import React from 'react/addons';
+
+import promise from 'es6-promise';
+promise.polyfill();
+
+import fetch from 'isomorphic-fetch';
+
+import fineUploader from 'fineUploader';
+import FileDragAndDrop from './file_drag_and_drop';
+
+var ReactS3FineUploader = React.createClass({
+
+    getInitialState() {
+        return {
+            filesToUpload: [],
+            uploader: new fineUploader.s3.FineUploaderBasic(this.propsToConfig())
+        };
+    },
+
+    componentDidMount() {
+        //console.log(JSON.stringify(this.propsToConfig()));
+        //let file = this.state.uploader.getResumableFilesData()[0];
+        //this.state.uploader.retry('1RKieODp_EBoDPNhISXBDNuA1JKdVuXCWhyk44DTK81WUQvpu3M8TXsKPLkjm3ICSvbbyR2KaHhEysvRQ_s4qHNFCbBiYrZ0Q8clXGCYtzk-');
+    },
+
+    propTypes: {
+        keyRoutine: React.PropTypes.shape({
+            url: React.PropTypes.string,
+            fileClass: React.PropTypes.string
+        }),
+        autoUpload: React.PropTypes.bool,
+        debug: React.PropTypes.bool,
+        objectProperties: React.PropTypes.shape({
+            acl: React.PropTypes.string
+        }),
+        request: React.PropTypes.shape({
+            endpoint: React.PropTypes.string,
+            accessKey: React.PropTypes.string,
+            params: React.PropTypes.shape({
+                csrfmiddlewaretoken: React.PropTypes.string
+            })
+        }),
+        signature: React.PropTypes.shape({
+            endpoint: React.PropTypes.string
+        }),
+        uploadSuccess: React.PropTypes.shape({
+            method: React.PropTypes.string,
+            endpoint: React.PropTypes.string,
+            params: React.PropTypes.shape({
+                isBrowserPreviewCapable: React.PropTypes.any, // maybe fix this later
+                bitcoin_ID_noPrefix: React.PropTypes.string
+            })
+        }),
+        cors: React.PropTypes.shape({
+            expected: React.PropTypes.bool
+        }),
+        chunking: React.PropTypes.shape({
+            enabled: React.PropTypes.bool
+        }),
+        resume: React.PropTypes.shape({
+            enabled: React.PropTypes.bool
+        }),
+        deleteFile: React.PropTypes.shape({
+            enabled: React.PropTypes.bool,
+            method: React.PropTypes.string,
+            endpoint: React.PropTypes.string
+        }),
+        session: React.PropTypes.shape({
+            endpoint: React.PropTypes.bool
+        }),
+        validation: React.PropTypes.shape({
+            itemLimit: React.PropTypes.number,
+            sizeLimit: React.PropTypes.string
+        }),
+        messages: React.PropTypes.shape({
+            unsupportedBrowser: React.PropTypes.string
+        }),
+        formatFileName: React.PropTypes.func,
+        multiple: React.PropTypes.bool,
+        retry: React.PropTypes.shape({
+            enableAuto: React.PropTypes.bool
+        })
+    },
+
+    propsToConfig() {
+        let objectProperties = this.props.objectProperties;
+        objectProperties['key'] = this.requestKey;
+
+        return {
+            autoUpload: this.props.autoUpload,
+            debug: this.props.debug,
+            objectProperties: objectProperties, // do a special key handling here
+            request: this.props.request,
+            signature: this.props.signature,
+            uploadSuccess: this.props.uploadSuccess,
+            cors: this.props.cors,
+            chunking: this.props.chunking,
+            resume: this.props.resume,
+            deleteFile: this.props.deleteFile,
+            session: this.props.session,
+            validation: this.props.validation,
+            messages: this.props.messages,
+            formatFileName: this.props.formatFileName,
+            multiple: this.props.multiple,
+            retry: this.props.retry,
+            callbacks: {
+                onSubmit: this.onSubmit,
+                onComplete: this.onComplete,
+                onDelete: this.onDelete,
+                onSessionRequestComplete: this.onSessionRequestComplete, 
+                onProgress: this.onProgress,
+                onRetry: this.onRetry,
+                onAutoRetry: this.onAutoRetry,
+                onManualRetry: this.onManualRetry,
+                onDeleteComplete: this.onDeleteComplete
+            }
+        };
+    },
+    getCookie(name) {
+        console.log(document.cookie);
+        let value = '; ' + document.cookie;
+        let parts = value.split('; ' + name + '=');
+        if (parts.length === 2) {
+            return parts.pop().split(';').shift();
+        }
+    },
+    requestKey(fileId) {
+        let filename = this.state.uploader.getName(fileId);
+        let defer = new fineUploader.Promise();
+        fetch(this.props.keyRoutine.url, {
+            method: 'post',
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+                'X-CSRFToken': this.getCookie('csrftoken')
+            },
+            credentials: 'include',
+            body: JSON.stringify({
+                'filename': filename,
+                'file_class': 'digitalwork'
+            })
+        })
+        .then((res) => {
+            return res.json();
+        })
+        .then((res) =>{
+            defer.success(res.key);
+        })
+        .catch((err) => {
+            console.error(err);
+        });
+        return defer;
+    },
+
+    /* FineUploader specific callback function handlers */
+
+    onSubmit() {
+        console.log('submit');
+    },
+
+    onComplete() {
+        console.log('complete');
+    },
+
+    onRetry() {
+        console.log('retry');
+    },
+
+    onAutoRetry() {
+        console.log('autoretry');
+    },
+
+    onManualRetry() {
+        console.log('manualretry');
+    },
+
+    onDelete() {
+        console.log('delete');
+    },
+
+    onCancel() {
+        console.log('cancel');
+    },
+
+    onSessionRequestComplete() {
+        console.log('sessionrequestcomplete');
+    },
+
+    onDeleteComplete(id, xhr, isError) {
+        if(isError) {
+            // also, sync files from state with the ones from fineuploader
+            let filesToUpload = JSON.parse(JSON.stringify(this.state.filesToUpload));
+            // splice because I can
+            filesToUpload.splice(fileId, 1);
+
+            // set state
+            this.setState({
+                filesToUpload: React.addons.update(this.state.filesToUpload, {$set: filesToUpload})
+            });
+        } else {
+            // TODO: add global notification
+        }
+    },
+
+    onProgress(id, name, uploadedBytes, totalBytes) {
+        var newState = React.addons.update(this.state, {
+            filesToUpload: { [id]: {
+                progress: { $set: (uploadedBytes/totalBytes)*100} }
+            }
+        });
+        this.setState(newState);
+    },
+
+    handleDeleteFile(fileId) {
+        // delete file from server
+        this.state.uploader.deleteFile(fileId);
+        // this is being continues in onDeleteFile, as 
+        // fineuploaders deleteFile does not return a correct callback or
+        // promise
+    },
+
+    handleUploadFile(files) {
+        this.state.uploader.addFiles(files);
+        let oldFiles = this.state.filesToUpload;
+        let oldAndNewFiles = this.state.uploader.getUploads();
+
+        // Add fineuploader specific information to new files
+        for(let i = 0; i < oldAndNewFiles.length; i++) {
+            for(let j = 0; j < files.length; j++) {
+                if(oldAndNewFiles[i].originalName === files[j].name) {
+                    oldAndNewFiles[i].progress = 0;
+                    oldAndNewFiles[i].type = files[j].type;
+                    oldAndNewFiles[i].url = URL.createObjectURL(files[j]);
+                }
+            }
+        }
+
+        // and re-add fineuploader specific information for old files as well
+        for(let i = 0; i < oldAndNewFiles.length; i++) {
+            for(let j = 0; j < oldFiles.length; j++) {
+                if(oldAndNewFiles[i].originalName === oldFiles[j].name) {
+                    oldAndNewFiles[i].progress = 0;
+                    oldAndNewFiles[i].type = oldFiles[j].type;
+                    oldAndNewFiles[i].url = oldFiles[j].url;
+                }
+            }
+        }
+
+        let newState = React.addons.update(this.state, {
+            filesToUpload: { $set: oldAndNewFiles }
+        });
+        this.setState(newState);
+    },
+
+    render() {
+        return (
+            <FileDragAndDrop 
+                onDrop={this.handleUploadFile}
+                filesToUpload={this.state.filesToUpload}
+                handleDeleteFile={this.handleDeleteFile}/>
+        );
+    }
+
+});
+
+
+export default ReactS3FineUploader;
diff --git a/js/components/ascribe_uploader/vendor/s3.fine-uploader.js b/js/components/ascribe_uploader/vendor/s3.fine-uploader.js
new file mode 100644
index 00000000..f660a79d
--- /dev/null
+++ b/js/components/ascribe_uploader/vendor/s3.fine-uploader.js
@@ -0,0 +1,14408 @@
+/*!
+* Fine Uploader
+*
+* Copyright 2015, Widen Enterprises, Inc. info@fineuploader.com
+*
+* Version: 5.2.2
+*
+* Homepage: http://fineuploader.com
+*
+* Repository: git://github.com/FineUploader/fine-uploader.git
+*
+* Licensed only under the Widen Commercial License (http://fineuploader.com/licensing).
+*/ 
+
+
+/*globals window, navigator, document, FormData, File, HTMLInputElement, XMLHttpRequest, Blob, Storage, ActiveXObject */
+/* jshint -W079 */
+var qq = function(element) {
+    "use strict";
+
+    return {
+        hide: function() {
+            element.style.display = "none";
+            return this;
+        },
+
+        /** Returns the function which detaches attached event */
+        attach: function(type, fn) {
+            if (element.addEventListener) {
+                element.addEventListener(type, fn, false);
+            } else if (element.attachEvent) {
+                element.attachEvent("on" + type, fn);
+            }
+            return function() {
+                qq(element).detach(type, fn);
+            };
+        },
+
+        detach: function(type, fn) {
+            if (element.removeEventListener) {
+                element.removeEventListener(type, fn, false);
+            } else if (element.attachEvent) {
+                element.detachEvent("on" + type, fn);
+            }
+            return this;
+        },
+
+        contains: function(descendant) {
+            // The [W3C spec](http://www.w3.org/TR/domcore/#dom-node-contains)
+            // says a `null` (or ostensibly `undefined`) parameter
+            // passed into `Node.contains` should result in a false return value.
+            // IE7 throws an exception if the parameter is `undefined` though.
+            if (!descendant) {
+                return false;
+            }
+
+            // compareposition returns false in this case
+            if (element === descendant) {
+                return true;
+            }
+
+            if (element.contains) {
+                return element.contains(descendant);
+            } else {
+                /*jslint bitwise: true*/
+                return !!(descendant.compareDocumentPosition(element) & 8);
+            }
+        },
+
+        /**
+         * Insert this element before elementB.
+         */
+        insertBefore: function(elementB) {
+            elementB.parentNode.insertBefore(element, elementB);
+            return this;
+        },
+
+        remove: function() {
+            element.parentNode.removeChild(element);
+            return this;
+        },
+
+        /**
+         * Sets styles for an element.
+         * Fixes opacity in IE6-8.
+         */
+        css: function(styles) {
+            /*jshint eqnull: true*/
+            if (element.style == null) {
+                throw new qq.Error("Can't apply style to node as it is not on the HTMLElement prototype chain!");
+            }
+
+            /*jshint -W116*/
+            if (styles.opacity != null) {
+                if (typeof element.style.opacity !== "string" && typeof (element.filters) !== "undefined") {
+                    styles.filter = "alpha(opacity=" + Math.round(100 * styles.opacity) + ")";
+                }
+            }
+            qq.extend(element.style, styles);
+
+            return this;
+        },
+
+        hasClass: function(name, considerParent) {
+            var re = new RegExp("(^| )" + name + "( |$)");
+            return re.test(element.className) || !!(considerParent && re.test(element.parentNode.className));
+        },
+
+        addClass: function(name) {
+            if (!qq(element).hasClass(name)) {
+                element.className += " " + name;
+            }
+            return this;
+        },
+
+        removeClass: function(name) {
+            var re = new RegExp("(^| )" + name + "( |$)");
+            element.className = element.className.replace(re, " ").replace(/^\s+|\s+$/g, "");
+            return this;
+        },
+
+        getByClass: function(className) {
+            var candidates,
+                result = [];
+
+            if (element.querySelectorAll) {
+                return element.querySelectorAll("." + className);
+            }
+
+            candidates = element.getElementsByTagName("*");
+
+            qq.each(candidates, function(idx, val) {
+                if (qq(val).hasClass(className)) {
+                    result.push(val);
+                }
+            });
+            return result;
+        },
+
+        children: function() {
+            var children = [],
+                child = element.firstChild;
+
+            while (child) {
+                if (child.nodeType === 1) {
+                    children.push(child);
+                }
+                child = child.nextSibling;
+            }
+
+            return children;
+        },
+
+        setText: function(text) {
+            element.innerText = text;
+            element.textContent = text;
+            return this;
+        },
+
+        clearText: function() {
+            return qq(element).setText("");
+        },
+
+        // Returns true if the attribute exists on the element
+        // AND the value of the attribute is NOT "false" (case-insensitive)
+        hasAttribute: function(attrName) {
+            var attrVal;
+
+            if (element.hasAttribute) {
+
+                if (!element.hasAttribute(attrName)) {
+                    return false;
+                }
+
+                /*jshint -W116*/
+                return (/^false$/i).exec(element.getAttribute(attrName)) == null;
+            }
+            else {
+                attrVal = element[attrName];
+
+                if (attrVal === undefined) {
+                    return false;
+                }
+
+                /*jshint -W116*/
+                return (/^false$/i).exec(attrVal) == null;
+            }
+        }
+    };
+};
+
+(function() {
+    "use strict";
+
+    qq.canvasToBlob = function(canvas, mime, quality) {
+        return qq.dataUriToBlob(canvas.toDataURL(mime, quality));
+    };
+
+    qq.dataUriToBlob = function(dataUri) {
+        var arrayBuffer, byteString,
+            createBlob = function(data, mime) {
+                var BlobBuilder = window.BlobBuilder ||
+                        window.WebKitBlobBuilder ||
+                        window.MozBlobBuilder ||
+                        window.MSBlobBuilder,
+                    blobBuilder = BlobBuilder && new BlobBuilder();
+
+                if (blobBuilder) {
+                    blobBuilder.append(data);
+                    return blobBuilder.getBlob(mime);
+                }
+                else {
+                    return new Blob([data], {type: mime});
+                }
+            },
+            intArray, mimeString;
+
+        // convert base64 to raw binary data held in a string
+        if (dataUri.split(",")[0].indexOf("base64") >= 0) {
+            byteString = atob(dataUri.split(",")[1]);
+        }
+        else {
+            byteString = decodeURI(dataUri.split(",")[1]);
+        }
+
+        // extract the MIME
+        mimeString = dataUri.split(",")[0]
+            .split(":")[1]
+            .split(";")[0];
+
+        // write the bytes of the binary string to an ArrayBuffer
+        arrayBuffer = new ArrayBuffer(byteString.length);
+        intArray = new Uint8Array(arrayBuffer);
+        qq.each(byteString, function(idx, character) {
+            intArray[idx] = character.charCodeAt(0);
+        });
+
+        return createBlob(arrayBuffer, mimeString);
+    };
+
+    qq.log = function(message, level) {
+        if (window.console) {
+            if (!level || level === "info") {
+                window.console.log(message);
+            }
+            else
+            {
+                if (window.console[level]) {
+                    window.console[level](message);
+                }
+                else {
+                    window.console.log("<" + level + "> " + message);
+                }
+            }
+        }
+    };
+
+    qq.isObject = function(variable) {
+        return variable && !variable.nodeType && Object.prototype.toString.call(variable) === "[object Object]";
+    };
+
+    qq.isFunction = function(variable) {
+        return typeof (variable) === "function";
+    };
+
+    /**
+     * Check the type of a value.  Is it an "array"?
+     *
+     * @param value value to test.
+     * @returns true if the value is an array or associated with an `ArrayBuffer`
+     */
+    qq.isArray = function(value) {
+        return Object.prototype.toString.call(value) === "[object Array]" ||
+            (value && window.ArrayBuffer && value.buffer && value.buffer.constructor === ArrayBuffer);
+    };
+
+    // Looks for an object on a `DataTransfer` object that is associated with drop events when utilizing the Filesystem API.
+    qq.isItemList = function(maybeItemList) {
+        return Object.prototype.toString.call(maybeItemList) === "[object DataTransferItemList]";
+    };
+
+    // Looks for an object on a `NodeList` or an `HTMLCollection`|`HTMLFormElement`|`HTMLSelectElement`
+    // object that is associated with collections of Nodes.
+    qq.isNodeList = function(maybeNodeList) {
+        return Object.prototype.toString.call(maybeNodeList) === "[object NodeList]" ||
+            // If `HTMLCollection` is the actual type of the object, we must determine this
+            // by checking for expected properties/methods on the object
+            (maybeNodeList.item && maybeNodeList.namedItem);
+    };
+
+    qq.isString = function(maybeString) {
+        return Object.prototype.toString.call(maybeString) === "[object String]";
+    };
+
+    qq.trimStr = function(string) {
+        if (String.prototype.trim) {
+            return string.trim();
+        }
+
+        return string.replace(/^\s+|\s+$/g, "");
+    };
+
+    /**
+     * @param str String to format.
+     * @returns {string} A string, swapping argument values with the associated occurrence of {} in the passed string.
+     */
+    qq.format = function(str) {
+
+        var args =  Array.prototype.slice.call(arguments, 1),
+            newStr = str,
+            nextIdxToReplace = newStr.indexOf("{}");
+
+        qq.each(args, function(idx, val) {
+            var strBefore = newStr.substring(0, nextIdxToReplace),
+                strAfter = newStr.substring(nextIdxToReplace + 2);
+
+            newStr = strBefore + val + strAfter;
+            nextIdxToReplace = newStr.indexOf("{}", nextIdxToReplace + val.length);
+
+            // End the loop if we have run out of tokens (when the arguments exceed the # of tokens)
+            if (nextIdxToReplace < 0) {
+                return false;
+            }
+        });
+
+        return newStr;
+    };
+
+    qq.isFile = function(maybeFile) {
+        return window.File && Object.prototype.toString.call(maybeFile) === "[object File]";
+    };
+
+    qq.isFileList = function(maybeFileList) {
+        return window.FileList && Object.prototype.toString.call(maybeFileList) === "[object FileList]";
+    };
+
+    qq.isFileOrInput = function(maybeFileOrInput) {
+        return qq.isFile(maybeFileOrInput) || qq.isInput(maybeFileOrInput);
+    };
+
+    qq.isInput = function(maybeInput, notFile) {
+        var evaluateType = function(type) {
+            var normalizedType = type.toLowerCase();
+
+            if (notFile) {
+                return normalizedType !== "file";
+            }
+
+            return normalizedType === "file";
+        };
+
+        if (window.HTMLInputElement) {
+            if (Object.prototype.toString.call(maybeInput) === "[object HTMLInputElement]") {
+                if (maybeInput.type && evaluateType(maybeInput.type)) {
+                    return true;
+                }
+            }
+        }
+        if (maybeInput.tagName) {
+            if (maybeInput.tagName.toLowerCase() === "input") {
+                if (maybeInput.type && evaluateType(maybeInput.type)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    };
+
+    qq.isBlob = function(maybeBlob) {
+        if (window.Blob && Object.prototype.toString.call(maybeBlob) === "[object Blob]") {
+            return true;
+        }
+    };
+
+    qq.isXhrUploadSupported = function() {
+        var input = document.createElement("input");
+        input.type = "file";
+
+        return (
+            input.multiple !== undefined &&
+                typeof File !== "undefined" &&
+                typeof FormData !== "undefined" &&
+                typeof (qq.createXhrInstance()).upload !== "undefined");
+    };
+
+    // Fall back to ActiveX is native XHR is disabled (possible in any version of IE).
+    qq.createXhrInstance = function() {
+        if (window.XMLHttpRequest) {
+            return new XMLHttpRequest();
+        }
+
+        try {
+            return new ActiveXObject("MSXML2.XMLHTTP.3.0");
+        }
+        catch (error) {
+            qq.log("Neither XHR or ActiveX are supported!", "error");
+            return null;
+        }
+    };
+
+    qq.isFolderDropSupported = function(dataTransfer) {
+        return dataTransfer.items &&
+            dataTransfer.items.length > 0 &&
+            dataTransfer.items[0].webkitGetAsEntry;
+    };
+
+    qq.isFileChunkingSupported = function() {
+        return !qq.androidStock() && //Android's stock browser cannot upload Blobs correctly
+            qq.isXhrUploadSupported() &&
+            (File.prototype.slice !== undefined || File.prototype.webkitSlice !== undefined || File.prototype.mozSlice !== undefined);
+    };
+
+    qq.sliceBlob = function(fileOrBlob, start, end) {
+        var slicer = fileOrBlob.slice || fileOrBlob.mozSlice || fileOrBlob.webkitSlice;
+
+        return slicer.call(fileOrBlob, start, end);
+    };
+
+    qq.arrayBufferToHex = function(buffer) {
+        var bytesAsHex = "",
+            bytes = new Uint8Array(buffer);
+
+        qq.each(bytes, function(idx, byt) {
+            var byteAsHexStr = byt.toString(16);
+
+            if (byteAsHexStr.length < 2) {
+                byteAsHexStr = "0" + byteAsHexStr;
+            }
+
+            bytesAsHex += byteAsHexStr;
+        });
+
+        return bytesAsHex;
+    };
+
+    qq.readBlobToHex = function(blob, startOffset, length) {
+        var initialBlob = qq.sliceBlob(blob, startOffset, startOffset + length),
+            fileReader = new FileReader(),
+            promise = new qq.Promise();
+
+        fileReader.onload = function() {
+            promise.success(qq.arrayBufferToHex(fileReader.result));
+        };
+
+        fileReader.onerror = promise.failure;
+
+        fileReader.readAsArrayBuffer(initialBlob);
+
+        return promise;
+    };
+
+    qq.extend = function(first, second, extendNested) {
+        qq.each(second, function(prop, val) {
+            if (extendNested && qq.isObject(val)) {
+                if (first[prop] === undefined) {
+                    first[prop] = {};
+                }
+                qq.extend(first[prop], val, true);
+            }
+            else {
+                first[prop] = val;
+            }
+        });
+
+        return first;
+    };
+
+    /**
+     * Allow properties in one object to override properties in another,
+     * keeping track of the original values from the target object.
+     *
+     * Note that the pre-overriden properties to be overriden by the source will be passed into the `sourceFn` when it is invoked.
+     *
+     * @param target Update properties in this object from some source
+     * @param sourceFn A function that, when invoked, will return properties that will replace properties with the same name in the target.
+     * @returns {object} The target object
+     */
+    qq.override = function(target, sourceFn) {
+        var super_ = {},
+            source = sourceFn(super_);
+
+        qq.each(source, function(srcPropName, srcPropVal) {
+            if (target[srcPropName] !== undefined) {
+                super_[srcPropName] = target[srcPropName];
+            }
+
+            target[srcPropName] = srcPropVal;
+        });
+
+        return target;
+    };
+
+    /**
+     * Searches for a given element (elt) in the array, returns -1 if it is not present.
+     */
+    qq.indexOf = function(arr, elt, from) {
+        if (arr.indexOf) {
+            return arr.indexOf(elt, from);
+        }
+
+        from = from || 0;
+        var len = arr.length;
+
+        if (from < 0) {
+            from += len;
+        }
+
+        for (; from < len; from += 1) {
+            if (arr.hasOwnProperty(from) && arr[from] === elt) {
+                return from;
+            }
+        }
+        return -1;
+    };
+
+    //this is a version 4 UUID
+    qq.getUniqueId = function() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+            /*jslint eqeq: true, bitwise: true*/
+            var r = Math.random() * 16 | 0, v = c == "x" ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    };
+
+    //
+    // Browsers and platforms detection
+    qq.ie = function() {
+        return navigator.userAgent.indexOf("MSIE") !== -1 ||
+            navigator.userAgent.indexOf("Trident") !== -1;
+    };
+
+    qq.ie7 = function() {
+        return navigator.userAgent.indexOf("MSIE 7") !== -1;
+    };
+
+    qq.ie8 = function() {
+        return navigator.userAgent.indexOf("MSIE 8") !== -1;
+    };
+
+    qq.ie10 = function() {
+        return navigator.userAgent.indexOf("MSIE 10") !== -1;
+    };
+
+    qq.ie11 = function() {
+        return qq.ie() && navigator.userAgent.indexOf("rv:11") !== -1;
+    };
+
+    qq.safari = function() {
+        return navigator.vendor !== undefined && navigator.vendor.indexOf("Apple") !== -1;
+    };
+
+    qq.chrome = function() {
+        return navigator.vendor !== undefined && navigator.vendor.indexOf("Google") !== -1;
+    };
+
+    qq.opera = function() {
+        return navigator.vendor !== undefined && navigator.vendor.indexOf("Opera") !== -1;
+    };
+
+    qq.firefox = function() {
+        return (!qq.ie11() && navigator.userAgent.indexOf("Mozilla") !== -1 && navigator.vendor !== undefined && navigator.vendor === "");
+    };
+
+    qq.windows = function() {
+        return navigator.platform === "Win32";
+    };
+
+    qq.android = function() {
+        return navigator.userAgent.toLowerCase().indexOf("android") !== -1;
+    };
+
+    // We need to identify the Android stock browser via the UA string to work around various bugs in this browser,
+    // such as the one that prevents a `Blob` from being uploaded.
+    qq.androidStock = function() {
+        return qq.android() && navigator.userAgent.toLowerCase().indexOf("chrome") < 0;
+    };
+
+    qq.ios6 = function() {
+        return qq.ios() && navigator.userAgent.indexOf(" OS 6_") !== -1;
+    };
+
+    qq.ios7 = function() {
+        return qq.ios() && navigator.userAgent.indexOf(" OS 7_") !== -1;
+    };
+
+    qq.ios8 = function() {
+        return qq.ios() && navigator.userAgent.indexOf(" OS 8_") !== -1;
+    };
+
+    // iOS 8.0.0
+    qq.ios800 = function() {
+        return qq.ios() && navigator.userAgent.indexOf(" OS 8_0 ") !== -1;
+    };
+
+    qq.ios = function() {
+        /*jshint -W014 */
+        return navigator.userAgent.indexOf("iPad") !== -1
+            || navigator.userAgent.indexOf("iPod") !== -1
+            || navigator.userAgent.indexOf("iPhone") !== -1;
+    };
+
+    qq.iosChrome = function() {
+        return qq.ios() && navigator.userAgent.indexOf("CriOS") !== -1;
+    };
+
+    qq.iosSafari = function() {
+        return qq.ios() && !qq.iosChrome() && navigator.userAgent.indexOf("Safari") !== -1;
+    };
+
+    qq.iosSafariWebView = function() {
+        return qq.ios() && !qq.iosChrome() && !qq.iosSafari();
+    };
+
+    //
+    // Events
+
+    qq.preventDefault = function(e) {
+        if (e.preventDefault) {
+            e.preventDefault();
+        } else {
+            e.returnValue = false;
+        }
+    };
+
+    /**
+     * Creates and returns element from html string
+     * Uses innerHTML to create an element
+     */
+    qq.toElement = (function() {
+        var div = document.createElement("div");
+        return function(html) {
+            div.innerHTML = html;
+            var element = div.firstChild;
+            div.removeChild(element);
+            return element;
+        };
+    }());
+
+    //key and value are passed to callback for each entry in the iterable item
+    qq.each = function(iterableItem, callback) {
+        var keyOrIndex, retVal;
+
+        if (iterableItem) {
+            // Iterate through [`Storage`](http://www.w3.org/TR/webstorage/#the-storage-interface) items
+            if (window.Storage && iterableItem.constructor === window.Storage) {
+                for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {
+                    retVal = callback(iterableItem.key(keyOrIndex), iterableItem.getItem(iterableItem.key(keyOrIndex)));
+                    if (retVal === false) {
+                        break;
+                    }
+                }
+            }
+            // `DataTransferItemList` & `NodeList` objects are array-like and should be treated as arrays
+            // when iterating over items inside the object.
+            else if (qq.isArray(iterableItem) || qq.isItemList(iterableItem) || qq.isNodeList(iterableItem)) {
+                for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {
+                    retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);
+                    if (retVal === false) {
+                        break;
+                    }
+                }
+            }
+            else if (qq.isString(iterableItem)) {
+                for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {
+                    retVal = callback(keyOrIndex, iterableItem.charAt(keyOrIndex));
+                    if (retVal === false) {
+                        break;
+                    }
+                }
+            }
+            else {
+                for (keyOrIndex in iterableItem) {
+                    if (Object.prototype.hasOwnProperty.call(iterableItem, keyOrIndex)) {
+                        retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);
+                        if (retVal === false) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    //include any args that should be passed to the new function after the context arg
+    qq.bind = function(oldFunc, context) {
+        if (qq.isFunction(oldFunc)) {
+            var args =  Array.prototype.slice.call(arguments, 2);
+
+            return function() {
+                var newArgs = qq.extend([], args);
+                if (arguments.length) {
+                    newArgs = newArgs.concat(Array.prototype.slice.call(arguments));
+                }
+                return oldFunc.apply(context, newArgs);
+            };
+        }
+
+        throw new Error("first parameter must be a function!");
+    };
+
+    /**
+     * obj2url() takes a json-object as argument and generates
+     * a querystring. pretty much like jQuery.param()
+     *
+     * how to use:
+     *
+     *    `qq.obj2url({a:'b',c:'d'},'http://any.url/upload?otherParam=value');`
+     *
+     * will result in:
+     *
+     *    `http://any.url/upload?otherParam=value&a=b&c=d`
+     *
+     * @param  Object JSON-Object
+     * @param  String current querystring-part
+     * @return String encoded querystring
+     */
+    qq.obj2url = function(obj, temp, prefixDone) {
+        /*jshint laxbreak: true*/
+        var uristrings = [],
+            prefix = "&",
+            add = function(nextObj, i) {
+                var nextTemp = temp
+                    ? (/\[\]$/.test(temp)) // prevent double-encoding
+                    ? temp
+                    : temp + "[" + i + "]"
+                    : i;
+                if ((nextTemp !== "undefined") && (i !== "undefined")) {
+                    uristrings.push(
+                        (typeof nextObj === "object")
+                            ? qq.obj2url(nextObj, nextTemp, true)
+                            : (Object.prototype.toString.call(nextObj) === "[object Function]")
+                            ? encodeURIComponent(nextTemp) + "=" + encodeURIComponent(nextObj())
+                            : encodeURIComponent(nextTemp) + "=" + encodeURIComponent(nextObj)
+                    );
+                }
+            };
+
+        if (!prefixDone && temp) {
+            prefix = (/\?/.test(temp)) ? (/\?$/.test(temp)) ? "" : "&" : "?";
+            uristrings.push(temp);
+            uristrings.push(qq.obj2url(obj));
+        } else if ((Object.prototype.toString.call(obj) === "[object Array]") && (typeof obj !== "undefined")) {
+            qq.each(obj, function(idx, val) {
+                add(val, idx);
+            });
+        } else if ((typeof obj !== "undefined") && (obj !== null) && (typeof obj === "object")) {
+            qq.each(obj, function(prop, val) {
+                add(val, prop);
+            });
+        } else {
+            uristrings.push(encodeURIComponent(temp) + "=" + encodeURIComponent(obj));
+        }
+
+        if (temp) {
+            return uristrings.join(prefix);
+        } else {
+            return uristrings.join(prefix)
+                .replace(/^&/, "")
+                .replace(/%20/g, "+");
+        }
+    };
+
+    qq.obj2FormData = function(obj, formData, arrayKeyName) {
+        if (!formData) {
+            formData = new FormData();
+        }
+
+        qq.each(obj, function(key, val) {
+            key = arrayKeyName ? arrayKeyName + "[" + key + "]" : key;
+
+            if (qq.isObject(val)) {
+                qq.obj2FormData(val, formData, key);
+            }
+            else if (qq.isFunction(val)) {
+                formData.append(key, val());
+            }
+            else {
+                formData.append(key, val);
+            }
+        });
+
+        return formData;
+    };
+
+    qq.obj2Inputs = function(obj, form) {
+        var input;
+
+        if (!form) {
+            form = document.createElement("form");
+        }
+
+        qq.obj2FormData(obj, {
+            append: function(key, val) {
+                input = document.createElement("input");
+                input.setAttribute("name", key);
+                input.setAttribute("value", val);
+                form.appendChild(input);
+            }
+        });
+
+        return form;
+    };
+
+    /**
+     * Not recommended for use outside of Fine Uploader since this falls back to an unchecked eval if JSON.parse is not
+     * implemented.  For a more secure JSON.parse polyfill, use Douglas Crockford's json2.js.
+     */
+    qq.parseJson = function(json) {
+        /*jshint evil: true*/
+        if (window.JSON && qq.isFunction(JSON.parse)) {
+            return JSON.parse(json);
+        } else {
+            return eval("(" + json + ")");
+        }
+    };
+
+    /**
+     * Retrieve the extension of a file, if it exists.
+     *
+     * @param filename
+     * @returns {string || undefined}
+     */
+    qq.getExtension = function(filename) {
+        var extIdx = filename.lastIndexOf(".") + 1;
+
+        if (extIdx > 0) {
+            return filename.substr(extIdx, filename.length - extIdx);
+        }
+    };
+
+    qq.getFilename = function(blobOrFileInput) {
+        /*jslint regexp: true*/
+
+        if (qq.isInput(blobOrFileInput)) {
+            // get input value and remove path to normalize
+            return blobOrFileInput.value.replace(/.*(\/|\\)/, "");
+        }
+        else if (qq.isFile(blobOrFileInput)) {
+            if (blobOrFileInput.fileName !== null && blobOrFileInput.fileName !== undefined) {
+                return blobOrFileInput.fileName;
+            }
+        }
+
+        return blobOrFileInput.name;
+    };
+
+    /**
+     * A generic module which supports object disposing in dispose() method.
+     * */
+    qq.DisposeSupport = function() {
+        var disposers = [];
+
+        return {
+            /** Run all registered disposers */
+            dispose: function() {
+                var disposer;
+                do {
+                    disposer = disposers.shift();
+                    if (disposer) {
+                        disposer();
+                    }
+                }
+                while (disposer);
+            },
+
+            /** Attach event handler and register de-attacher as a disposer */
+            attach: function() {
+                var args = arguments;
+                /*jslint undef:true*/
+                this.addDisposer(qq(args[0]).attach.apply(this, Array.prototype.slice.call(arguments, 1)));
+            },
+
+            /** Add disposer to the collection */
+            addDisposer: function(disposeFunction) {
+                disposers.push(disposeFunction);
+            }
+        };
+    };
+}());
+
+/* globals qq */
+/**
+ * Fine Uploader top-level Error container.  Inherits from `Error`.
+ */
+(function() {
+    "use strict";
+
+    qq.Error = function(message) {
+        this.message = "[Fine Uploader " + qq.version + "] " + message;
+    };
+
+    qq.Error.prototype = new Error();
+}());
+
+/*global qq */
+qq.version = "5.2.2";
+
+/* globals qq */
+qq.supportedFeatures = (function() {
+    "use strict";
+
+    var supportsUploading,
+        supportsUploadingBlobs,
+        supportsFileDrop,
+        supportsAjaxFileUploading,
+        supportsFolderDrop,
+        supportsChunking,
+        supportsResume,
+        supportsUploadViaPaste,
+        supportsUploadCors,
+        supportsDeleteFileXdr,
+        supportsDeleteFileCorsXhr,
+        supportsDeleteFileCors,
+        supportsFolderSelection,
+        supportsImagePreviews,
+        supportsUploadProgress;
+
+    function testSupportsFileInputElement() {
+        var supported = true,
+            tempInput;
+
+        try {
+            tempInput = document.createElement("input");
+            tempInput.type = "file";
+            qq(tempInput).hide();
+
+            if (tempInput.disabled) {
+                supported = false;
+            }
+        }
+        catch (ex) {
+            supported = false;
+        }
+
+        return supported;
+    }
+
+    //only way to test for Filesystem API support since webkit does not expose the DataTransfer interface
+    function isChrome21OrHigher() {
+        return (qq.chrome() || qq.opera()) &&
+            navigator.userAgent.match(/Chrome\/[2][1-9]|Chrome\/[3-9][0-9]/) !== undefined;
+    }
+
+    //only way to test for complete Clipboard API support at this time
+    function isChrome14OrHigher() {
+        return (qq.chrome() || qq.opera()) &&
+            navigator.userAgent.match(/Chrome\/[1][4-9]|Chrome\/[2-9][0-9]/) !== undefined;
+    }
+
+    //Ensure we can send cross-origin `XMLHttpRequest`s
+    function isCrossOriginXhrSupported() {
+        if (window.XMLHttpRequest) {
+            var xhr = qq.createXhrInstance();
+
+            //Commonly accepted test for XHR CORS support.
+            return xhr.withCredentials !== undefined;
+        }
+
+        return false;
+    }
+
+    //Test for (terrible) cross-origin ajax transport fallback for IE9 and IE8
+    function isXdrSupported() {
+        return window.XDomainRequest !== undefined;
+    }
+
+    // CORS Ajax requests are supported if it is either possible to send credentialed `XMLHttpRequest`s,
+    // or if `XDomainRequest` is an available alternative.
+    function isCrossOriginAjaxSupported() {
+        if (isCrossOriginXhrSupported()) {
+            return true;
+        }
+
+        return isXdrSupported();
+    }
+
+    function isFolderSelectionSupported() {
+        // We know that folder selection is only supported in Chrome via this proprietary attribute for now
+        return document.createElement("input").webkitdirectory !== undefined;
+    }
+
+    function isLocalStorageSupported() {
+        try {
+            return !!window.localStorage;
+        }
+        catch (error) {
+            // probably caught a security exception, so no localStorage for you
+            return false;
+        }
+    }
+
+    function isDragAndDropSupported() {
+        var span = document.createElement("span");
+
+        return ("draggable" in span || ("ondragstart" in span && "ondrop" in span)) &&
+            !qq.android() && !qq.ios();
+    }
+
+    supportsUploading = testSupportsFileInputElement();
+
+    supportsAjaxFileUploading = supportsUploading && qq.isXhrUploadSupported();
+
+    supportsUploadingBlobs = supportsAjaxFileUploading && !qq.androidStock();
+
+    supportsFileDrop = supportsAjaxFileUploading && isDragAndDropSupported();
+
+    supportsFolderDrop = supportsFileDrop && isChrome21OrHigher();
+
+    supportsChunking = supportsAjaxFileUploading && qq.isFileChunkingSupported();
+
+    supportsResume = supportsAjaxFileUploading && supportsChunking && isLocalStorageSupported();
+
+    supportsUploadViaPaste = supportsAjaxFileUploading && isChrome14OrHigher();
+
+    supportsUploadCors = supportsUploading && (window.postMessage !== undefined || supportsAjaxFileUploading);
+
+    supportsDeleteFileCorsXhr = isCrossOriginXhrSupported();
+
+    supportsDeleteFileXdr = isXdrSupported();
+
+    supportsDeleteFileCors = isCrossOriginAjaxSupported();
+
+    supportsFolderSelection = isFolderSelectionSupported();
+
+    supportsImagePreviews = supportsAjaxFileUploading && window.FileReader !== undefined;
+
+    supportsUploadProgress = (function() {
+        if (supportsAjaxFileUploading) {
+            return !qq.androidStock() && !qq.iosChrome();
+        }
+        return false;
+    }());
+
+    return {
+        ajaxUploading: supportsAjaxFileUploading,
+        blobUploading: supportsUploadingBlobs,
+        canDetermineSize: supportsAjaxFileUploading,
+        chunking: supportsChunking,
+        deleteFileCors: supportsDeleteFileCors,
+        deleteFileCorsXdr: supportsDeleteFileXdr, //NOTE: will also return true in IE10, where XDR is also supported
+        deleteFileCorsXhr: supportsDeleteFileCorsXhr,
+        dialogElement: !!window.HTMLDialogElement,
+        fileDrop: supportsFileDrop,
+        folderDrop: supportsFolderDrop,
+        folderSelection: supportsFolderSelection,
+        imagePreviews: supportsImagePreviews,
+        imageValidation: supportsImagePreviews,
+        itemSizeValidation: supportsAjaxFileUploading,
+        pause: supportsChunking,
+        progressBar: supportsUploadProgress,
+        resume: supportsResume,
+        scaling: supportsImagePreviews && supportsUploadingBlobs,
+        tiffPreviews: qq.safari(), // Not the best solution, but simple and probably accurate enough (for now)
+        unlimitedScaledImageSize: !qq.ios(), // false simply indicates that there is some known limit
+        uploading: supportsUploading,
+        uploadCors: supportsUploadCors,
+        uploadCustomHeaders: supportsAjaxFileUploading,
+        uploadNonMultipart: supportsAjaxFileUploading,
+        uploadViaPaste: supportsUploadViaPaste
+    };
+
+}());
+
+/*globals qq*/
+
+// Is the passed object a promise instance?
+qq.isGenericPromise = function(maybePromise) {
+    "use strict";
+    return !!(maybePromise && maybePromise.then && qq.isFunction(maybePromise.then));
+};
+
+qq.Promise = function() {
+    "use strict";
+
+    var successArgs, failureArgs,
+        successCallbacks = [],
+        failureCallbacks = [],
+        doneCallbacks = [],
+        state = 0;
+
+    qq.extend(this, {
+        then: function(onSuccess, onFailure) {
+            if (state === 0) {
+                if (onSuccess) {
+                    successCallbacks.push(onSuccess);
+                }
+                if (onFailure) {
+                    failureCallbacks.push(onFailure);
+                }
+            }
+            else if (state === -1) {
+                onFailure && onFailure.apply(null, failureArgs);
+            }
+            else if (onSuccess) {
+                onSuccess.apply(null, successArgs);
+            }
+
+            return this;
+        },
+
+        done: function(callback) {
+            if (state === 0) {
+                doneCallbacks.push(callback);
+            }
+            else {
+                callback.apply(null, failureArgs === undefined ? successArgs : failureArgs);
+            }
+
+            return this;
+        },
+
+        success: function() {
+            state = 1;
+            successArgs = arguments;
+
+            if (successCallbacks.length) {
+                qq.each(successCallbacks, function(idx, callback) {
+                    callback.apply(null, successArgs);
+                });
+            }
+
+            if (doneCallbacks.length) {
+                qq.each(doneCallbacks, function(idx, callback) {
+                    callback.apply(null, successArgs);
+                });
+            }
+
+            return this;
+        },
+
+        failure: function() {
+            state = -1;
+            failureArgs = arguments;
+
+            if (failureCallbacks.length) {
+                qq.each(failureCallbacks, function(idx, callback) {
+                    callback.apply(null, failureArgs);
+                });
+            }
+
+            if (doneCallbacks.length) {
+                qq.each(doneCallbacks, function(idx, callback) {
+                    callback.apply(null, failureArgs);
+                });
+            }
+
+            return this;
+        }
+    });
+};
+
+/* globals qq */
+/**
+ * Placeholder for a Blob that will be generated on-demand.
+ *
+ * @param referenceBlob Parent of the generated blob
+ * @param onCreate Function to invoke when the blob must be created.  Must be promissory.
+ * @constructor
+ */
+qq.BlobProxy = function(referenceBlob, onCreate) {
+    "use strict";
+
+    qq.extend(this, {
+        referenceBlob: referenceBlob,
+
+        create: function() {
+            return onCreate(referenceBlob);
+        }
+    });
+};
+
+/*globals qq*/
+
+/**
+ * This module represents an upload or "Select File(s)" button.  It's job is to embed an opaque `<input type="file">`
+ * element as a child of a provided "container" element.  This "container" element (`options.element`) is used to provide
+ * a custom style for the `<input type="file">` element.  The ability to change the style of the container element is also
+ * provided here by adding CSS classes to the container on hover/focus.
+ *
+ * TODO Eliminate the mouseover and mouseout event handlers since the :hover CSS pseudo-class should now be
+ * available on all supported browsers.
+ *
+ * @param o Options to override the default values
+ */
+qq.UploadButton = function(o) {
+    "use strict";
+
+    var self = this,
+
+        disposeSupport = new qq.DisposeSupport(),
+
+        options = {
+            // "Container" element
+            element: null,
+
+            // If true adds `multiple` attribute to `<input type="file">`
+            multiple: false,
+
+            // Corresponds to the `accept` attribute on the associated `<input type="file">`
+            acceptFiles: null,
+
+            // A true value allows folders to be selected, if supported by the UA
+            folders: false,
+
+            // `name` attribute of `<input type="file">`
+            name: "qqfile",
+
+            // Called when the browser invokes the onchange handler on the `<input type="file">`
+            onChange: function(input) {},
+
+            ios8BrowserCrashWorkaround: false,
+
+            // **This option will be removed** in the future as the :hover CSS pseudo-class is available on all supported browsers
+            hoverClass: "qq-upload-button-hover",
+
+            focusClass: "qq-upload-button-focus"
+        },
+        input, buttonId;
+
+    // Overrides any of the default option values with any option values passed in during construction.
+    qq.extend(options, o);
+
+    buttonId = qq.getUniqueId();
+
+    // Embed an opaque `<input type="file">` element as a child of `options.element`.
+    function createInput() {
+        var input = document.createElement("input");
+
+        input.setAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME, buttonId);
+        input.setAttribute("title", "file input");
+
+        self.setMultiple(options.multiple, input);
+
+        if (options.folders && qq.supportedFeatures.folderSelection) {
+            // selecting directories is only possible in Chrome now, via a vendor-specific prefixed attribute
+            input.setAttribute("webkitdirectory", "");
+        }
+
+        if (options.acceptFiles) {
+            input.setAttribute("accept", options.acceptFiles);
+        }
+
+        input.setAttribute("type", "file");
+        input.setAttribute("name", options.name);
+
+        qq(input).css({
+            position: "absolute",
+            // in Opera only 'browse' button
+            // is clickable and it is located at
+            // the right side of the input
+            right: 0,
+            top: 0,
+            fontFamily: "Arial",
+            // It's especially important to make this an arbitrarily large value
+            // to ensure the rendered input button in IE takes up the entire
+            // space of the container element.  Otherwise, the left side of the
+            // button will require a double-click to invoke the file chooser.
+            // In other browsers, this might cause other issues, so a large font-size
+            // is only used in IE.  There is a bug in IE8 where the opacity style is  ignored
+            // in some cases when the font-size is large.  So, this workaround is not applied
+            // to IE8.
+            fontSize: qq.ie() && !qq.ie8() ? "3500px" : "118px",
+            margin: 0,
+            padding: 0,
+            cursor: "pointer",
+            opacity: 0
+        });
+
+        // Setting the file input's height to 100% in IE7 causes
+        // most of the visible button to be unclickable.
+        !qq.ie7() && qq(input).css({height: "100%"});
+
+        options.element.appendChild(input);
+
+        disposeSupport.attach(input, "change", function() {
+            options.onChange(input);
+        });
+
+        // **These event handlers will be removed** in the future as the :hover CSS pseudo-class is available on all supported browsers
+        disposeSupport.attach(input, "mouseover", function() {
+            qq(options.element).addClass(options.hoverClass);
+        });
+        disposeSupport.attach(input, "mouseout", function() {
+            qq(options.element).removeClass(options.hoverClass);
+        });
+
+        disposeSupport.attach(input, "focus", function() {
+            qq(options.element).addClass(options.focusClass);
+        });
+        disposeSupport.attach(input, "blur", function() {
+            qq(options.element).removeClass(options.focusClass);
+        });
+
+        return input;
+    }
+
+    // Make button suitable container for input
+    qq(options.element).css({
+        position: "relative",
+        overflow: "hidden",
+        // Make sure browse button is in the right side in Internet Explorer
+        direction: "ltr"
+    });
+
+    // Exposed API
+    qq.extend(this, {
+        getInput: function() {
+            return input;
+        },
+
+        getButtonId: function() {
+            return buttonId;
+        },
+
+        setMultiple: function(isMultiple, optInput) {
+            var input = optInput || this.getInput();
+
+            // Temporary workaround for bug in in iOS8 UIWebView that causes the browser to crash
+            // before the file chooser appears if the file input doesn't contain a multiple attribute.
+            // See #1283.
+            if (options.ios8BrowserCrashWorkaround && qq.ios8() && (qq.iosChrome() || qq.iosSafariWebView())) {
+                input.setAttribute("multiple", "");
+            }
+
+            else {
+                if (isMultiple) {
+                    input.setAttribute("multiple", "");
+                }
+                else {
+                    input.removeAttribute("multiple");
+                }
+            }
+        },
+
+        setAcceptFiles: function(acceptFiles) {
+            if (acceptFiles !== options.acceptFiles) {
+                input.setAttribute("accept", acceptFiles);
+            }
+        },
+
+        reset: function() {
+            if (input.parentNode) {
+                qq(input).remove();
+            }
+
+            qq(options.element).removeClass(options.focusClass);
+            input = null;
+            input = createInput();
+        }
+    });
+
+    input = createInput();
+};
+
+qq.UploadButton.BUTTON_ID_ATTR_NAME = "qq-button-id";
+
+/*globals qq */
+qq.UploadData = function(uploaderProxy) {
+    "use strict";
+
+    var data = [],
+        byUuid = {},
+        byStatus = {},
+        byProxyGroupId = {},
+        byBatchId = {};
+
+    function getDataByIds(idOrIds) {
+        if (qq.isArray(idOrIds)) {
+            var entries = [];
+
+            qq.each(idOrIds, function(idx, id) {
+                entries.push(data[id]);
+            });
+
+            return entries;
+        }
+
+        return data[idOrIds];
+    }
+
+    function getDataByUuids(uuids) {
+        if (qq.isArray(uuids)) {
+            var entries = [];
+
+            qq.each(uuids, function(idx, uuid) {
+                entries.push(data[byUuid[uuid]]);
+            });
+
+            return entries;
+        }
+
+        return data[byUuid[uuids]];
+    }
+
+    function getDataByStatus(status) {
+        var statusResults = [],
+            statuses = [].concat(status);
+
+        qq.each(statuses, function(index, statusEnum) {
+            var statusResultIndexes = byStatus[statusEnum];
+
+            if (statusResultIndexes !== undefined) {
+                qq.each(statusResultIndexes, function(i, dataIndex) {
+                    statusResults.push(data[dataIndex]);
+                });
+            }
+        });
+
+        return statusResults;
+    }
+
+    qq.extend(this, {
+        /**
+         * Adds a new file to the data cache for tracking purposes.
+         *
+         * @param spec Data that describes this file.  Possible properties are:
+         *
+         * - uuid: Initial UUID for this file.
+         * - name: Initial name of this file.
+         * - size: Size of this file, omit if this cannot be determined
+         * - status: Initial `qq.status` for this file.  Omit for `qq.status.SUBMITTING`.
+         * - batchId: ID of the batch this file belongs to
+         * - proxyGroupId: ID of the proxy group associated with this file
+         *
+         * @returns {number} Internal ID for this file.
+         */
+        addFile: function(spec) {
+            var status = spec.status || qq.status.SUBMITTING,
+                id = data.push({
+                    name: spec.name,
+                    originalName: spec.name,
+                    uuid: spec.uuid,
+                    size: spec.size == null ? -1 : spec.size,
+                    status: status
+                }) - 1;
+
+            if (spec.batchId) {
+                data[id].batchId = spec.batchId;
+
+                if (byBatchId[spec.batchId] === undefined) {
+                    byBatchId[spec.batchId] = [];
+                }
+                byBatchId[spec.batchId].push(id);
+            }
+
+            if (spec.proxyGroupId) {
+                data[id].proxyGroupId = spec.proxyGroupId;
+
+                if (byProxyGroupId[spec.proxyGroupId] === undefined) {
+                    byProxyGroupId[spec.proxyGroupId] = [];
+                }
+                byProxyGroupId[spec.proxyGroupId].push(id);
+            }
+
+            data[id].id = id;
+            byUuid[spec.uuid] = id;
+
+            if (byStatus[status] === undefined) {
+                byStatus[status] = [];
+            }
+            byStatus[status].push(id);
+
+            uploaderProxy.onStatusChange(id, null, status);
+
+            return id;
+        },
+
+        retrieve: function(optionalFilter) {
+            if (qq.isObject(optionalFilter) && data.length)  {
+                if (optionalFilter.id !== undefined) {
+                    return getDataByIds(optionalFilter.id);
+                }
+
+                else if (optionalFilter.uuid !== undefined) {
+                    return getDataByUuids(optionalFilter.uuid);
+                }
+
+                else if (optionalFilter.status) {
+                    return getDataByStatus(optionalFilter.status);
+                }
+            }
+            else {
+                return qq.extend([], data, true);
+            }
+        },
+
+        reset: function() {
+            data = [];
+            byUuid = {};
+            byStatus = {};
+            byBatchId = {};
+        },
+
+        setStatus: function(id, newStatus) {
+            var oldStatus = data[id].status,
+                byStatusOldStatusIndex = qq.indexOf(byStatus[oldStatus], id);
+
+            byStatus[oldStatus].splice(byStatusOldStatusIndex, 1);
+
+            data[id].status = newStatus;
+
+            if (byStatus[newStatus] === undefined) {
+                byStatus[newStatus] = [];
+            }
+            byStatus[newStatus].push(id);
+
+            uploaderProxy.onStatusChange(id, oldStatus, newStatus);
+        },
+
+        uuidChanged: function(id, newUuid) {
+            var oldUuid = data[id].uuid;
+
+            data[id].uuid = newUuid;
+            byUuid[newUuid] = id;
+            delete byUuid[oldUuid];
+        },
+
+        updateName: function(id, newName) {
+            data[id].name = newName;
+        },
+
+        updateSize: function(id, newSize) {
+            data[id].size = newSize;
+        },
+
+        // Only applicable if this file has a parent that we may want to reference later.
+        setParentId: function(targetId, parentId) {
+            data[targetId].parentId = parentId;
+        },
+
+        getIdsInProxyGroup: function(id) {
+            var proxyGroupId = data[id].proxyGroupId;
+
+            if (proxyGroupId) {
+                return byProxyGroupId[proxyGroupId];
+            }
+            return [];
+        },
+
+        getIdsInBatch: function(id) {
+            var batchId = data[id].batchId;
+
+            return byBatchId[batchId];
+        }
+    });
+};
+
+qq.status = {
+    SUBMITTING: "submitting",
+    SUBMITTED: "submitted",
+    REJECTED: "rejected",
+    QUEUED: "queued",
+    CANCELED: "canceled",
+    PAUSED: "paused",
+    UPLOADING: "uploading",
+    UPLOAD_RETRYING: "retrying upload",
+    UPLOAD_SUCCESSFUL: "upload successful",
+    UPLOAD_FAILED: "upload failed",
+    DELETE_FAILED: "delete failed",
+    DELETING: "deleting",
+    DELETED: "deleted"
+};
+
+/*globals qq*/
+/**
+ * Defines the public API for FineUploaderBasic mode.
+ */
+(function() {
+    "use strict";
+
+    qq.basePublicApi = {
+        // DEPRECATED - TODO REMOVE IN NEXT MAJOR RELEASE (replaced by addFiles)
+        addBlobs: function(blobDataOrArray, params, endpoint) {
+            this.addFiles(blobDataOrArray, params, endpoint);
+        },
+
+        addFiles: function(data, params, endpoint) {
+            this._maybeHandleIos8SafariWorkaround();
+
+            var batchId = this._storedIds.length === 0 ? qq.getUniqueId() : this._currentBatchId,
+
+                processBlob = qq.bind(function(blob) {
+                    this._handleNewFile({
+                        blob: blob,
+                        name: this._options.blobs.defaultName
+                    }, batchId, verifiedFiles);
+                }, this),
+
+                processBlobData = qq.bind(function(blobData) {
+                    this._handleNewFile(blobData, batchId, verifiedFiles);
+                }, this),
+
+                processCanvas = qq.bind(function(canvas) {
+                    var blob = qq.canvasToBlob(canvas);
+
+                    this._handleNewFile({
+                        blob: blob,
+                        name: this._options.blobs.defaultName + ".png"
+                    }, batchId, verifiedFiles);
+                }, this),
+
+                processCanvasData = qq.bind(function(canvasData) {
+                    var normalizedQuality = canvasData.quality && canvasData.quality / 100,
+                        blob = qq.canvasToBlob(canvasData.canvas, canvasData.type, normalizedQuality);
+
+                    this._handleNewFile({
+                        blob: blob,
+                        name: canvasData.name
+                    }, batchId, verifiedFiles);
+                }, this),
+
+                processFileOrInput = qq.bind(function(fileOrInput) {
+                    if (qq.isInput(fileOrInput) && qq.supportedFeatures.ajaxUploading) {
+                        var files = Array.prototype.slice.call(fileOrInput.files),
+                            self = this;
+
+                        qq.each(files, function(idx, file) {
+                            self._handleNewFile(file, batchId, verifiedFiles);
+                        });
+                    }
+                    else {
+                        this._handleNewFile(fileOrInput, batchId, verifiedFiles);
+                    }
+                }, this),
+
+                normalizeData = function() {
+                    if (qq.isFileList(data)) {
+                        data = Array.prototype.slice.call(data);
+                    }
+                    data = [].concat(data);
+                },
+
+                self = this,
+                verifiedFiles = [];
+
+            this._currentBatchId = batchId;
+
+            if (data) {
+                normalizeData();
+
+                qq.each(data, function(idx, fileContainer) {
+                    if (qq.isFileOrInput(fileContainer)) {
+                        processFileOrInput(fileContainer);
+                    }
+                    else if (qq.isBlob(fileContainer)) {
+                        processBlob(fileContainer);
+                    }
+                    else if (qq.isObject(fileContainer)) {
+                        if (fileContainer.blob && fileContainer.name) {
+                            processBlobData(fileContainer);
+                        }
+                        else if (fileContainer.canvas && fileContainer.name) {
+                            processCanvasData(fileContainer);
+                        }
+                    }
+                    else if (fileContainer.tagName && fileContainer.tagName.toLowerCase() === "canvas") {
+                        processCanvas(fileContainer);
+                    }
+                    else {
+                        self.log(fileContainer + " is not a valid file container!  Ignoring!", "warn");
+                    }
+                });
+
+                this.log("Received " + verifiedFiles.length + " files.");
+                this._prepareItemsForUpload(verifiedFiles, params, endpoint);
+            }
+        },
+
+        cancel: function(id) {
+            this._handler.cancel(id);
+        },
+
+        cancelAll: function() {
+            var storedIdsCopy = [],
+                self = this;
+
+            qq.extend(storedIdsCopy, this._storedIds);
+            qq.each(storedIdsCopy, function(idx, storedFileId) {
+                self.cancel(storedFileId);
+            });
+
+            this._handler.cancelAll();
+        },
+
+        clearStoredFiles: function() {
+            this._storedIds = [];
+        },
+
+        continueUpload: function(id) {
+            var uploadData = this._uploadData.retrieve({id: id});
+
+            if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {
+                return false;
+            }
+
+            if (uploadData.status === qq.status.PAUSED) {
+                this.log(qq.format("Paused file ID {} ({}) will be continued.  Not paused.", id, this.getName(id)));
+                this._uploadFile(id);
+                return true;
+            }
+            else {
+                this.log(qq.format("Ignoring continue for file ID {} ({}).  Not paused.", id, this.getName(id)), "error");
+            }
+
+            return false;
+        },
+
+        deleteFile: function(id) {
+            return this._onSubmitDelete(id);
+        },
+
+        // TODO document?
+        doesExist: function(fileOrBlobId) {
+            return this._handler.isValid(fileOrBlobId);
+        },
+
+        // Generate a variable size thumbnail on an img or canvas,
+        // returning a promise that is fulfilled when the attempt completes.
+        // Thumbnail can either be based off of a URL for an image returned
+        // by the server in the upload response, or the associated `Blob`.
+        drawThumbnail: function(fileId, imgOrCanvas, maxSize, fromServer) {
+            var promiseToReturn = new qq.Promise(),
+                fileOrUrl, options;
+
+            if (this._imageGenerator) {
+                fileOrUrl = this._thumbnailUrls[fileId];
+                options = {
+                    scale: maxSize > 0,
+                    maxSize: maxSize > 0 ? maxSize : null
+                };
+
+                // If client-side preview generation is possible
+                // and we are not specifically looking for the image URl returned by the server...
+                if (!fromServer && qq.supportedFeatures.imagePreviews) {
+                    fileOrUrl = this.getFile(fileId);
+                }
+
+                /* jshint eqeqeq:false,eqnull:true */
+                if (fileOrUrl == null) {
+                    promiseToReturn.failure({container: imgOrCanvas, error: "File or URL not found."});
+                }
+                else {
+                    this._imageGenerator.generate(fileOrUrl, imgOrCanvas, options).then(
+                        function success(modifiedContainer) {
+                            promiseToReturn.success(modifiedContainer);
+                        },
+
+                        function failure(container, reason) {
+                            promiseToReturn.failure({container: container, error: reason || "Problem generating thumbnail"});
+                        }
+                    );
+                }
+            }
+            else {
+                promiseToReturn.failure({container: imgOrCanvas, error: "Missing image generator module"});
+            }
+
+            return promiseToReturn;
+        },
+
+        getButton: function(fileId) {
+            return this._getButton(this._buttonIdsForFileIds[fileId]);
+        },
+
+        getEndpoint: function(fileId) {
+            return this._endpointStore.get(fileId);
+        },
+
+        getFile: function(fileOrBlobId) {
+            return this._handler.getFile(fileOrBlobId) || null;
+        },
+
+        getInProgress: function() {
+            return this._uploadData.retrieve({
+                status: [
+                    qq.status.UPLOADING,
+                    qq.status.UPLOAD_RETRYING,
+                    qq.status.QUEUED
+                ]
+            }).length;
+        },
+
+        getName: function(id) {
+            return this._uploadData.retrieve({id: id}).name;
+        },
+
+                // Parent ID for a specific file, or null if this is the parent, or if it has no parent.
+        getParentId: function(id) {
+            var uploadDataEntry = this.getUploads({id: id}),
+                parentId = null;
+
+            if (uploadDataEntry) {
+                if (uploadDataEntry.parentId !== undefined) {
+                    parentId = uploadDataEntry.parentId;
+                }
+            }
+
+            return parentId;
+        },
+
+        getResumableFilesData: function() {
+            return this._handler.getResumableFilesData();
+        },
+
+        getSize: function(id) {
+            return this._uploadData.retrieve({id: id}).size;
+        },
+
+        getNetUploads: function() {
+            return this._netUploaded;
+        },
+
+        getRemainingAllowedItems: function() {
+            var allowedItems = this._currentItemLimit;
+
+            if (allowedItems > 0) {
+                return allowedItems - this._netUploadedOrQueued;
+            }
+
+            return null;
+        },
+
+        getUploads: function(optionalFilter) {
+            return this._uploadData.retrieve(optionalFilter);
+        },
+
+        getUuid: function(id) {
+            return this._uploadData.retrieve({id: id}).uuid;
+        },
+
+        log: function(str, level) {
+            if (this._options.debug && (!level || level === "info")) {
+                qq.log("[Fine Uploader " + qq.version + "] " + str);
+            }
+            else if (level && level !== "info") {
+                qq.log("[Fine Uploader " + qq.version + "] " + str, level);
+
+            }
+        },
+
+        pauseUpload: function(id) {
+            var uploadData = this._uploadData.retrieve({id: id});
+
+            if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {
+                return false;
+            }
+
+            // Pause only really makes sense if the file is uploading or retrying
+            if (qq.indexOf([qq.status.UPLOADING, qq.status.UPLOAD_RETRYING], uploadData.status) >= 0) {
+                if (this._handler.pause(id)) {
+                    this._uploadData.setStatus(id, qq.status.PAUSED);
+                    return true;
+                }
+                else {
+                    this.log(qq.format("Unable to pause file ID {} ({}).", id, this.getName(id)), "error");
+                }
+            }
+            else {
+                this.log(qq.format("Ignoring pause for file ID {} ({}).  Not in progress.", id, this.getName(id)), "error");
+            }
+
+            return false;
+        },
+
+        reset: function() {
+            this.log("Resetting uploader...");
+
+            this._handler.reset();
+            this._storedIds = [];
+            this._autoRetries = [];
+            this._retryTimeouts = [];
+            this._preventRetries = [];
+            this._thumbnailUrls = [];
+
+            qq.each(this._buttons, function(idx, button) {
+                button.reset();
+            });
+
+            this._paramsStore.reset();
+            this._endpointStore.reset();
+            this._netUploadedOrQueued = 0;
+            this._netUploaded = 0;
+            this._uploadData.reset();
+            this._buttonIdsForFileIds = [];
+
+            this._pasteHandler && this._pasteHandler.reset();
+            this._options.session.refreshOnReset && this._refreshSessionData();
+
+            this._succeededSinceLastAllComplete = [];
+            this._failedSinceLastAllComplete = [];
+
+            this._totalProgress && this._totalProgress.reset();
+        },
+
+        retry: function(id) {
+            return this._manualRetry(id);
+        },
+
+        scaleImage: function(id, specs) {
+            var self = this;
+
+            return qq.Scaler.prototype.scaleImage(id, specs, {
+                log: qq.bind(self.log, self),
+                getFile: qq.bind(self.getFile, self),
+                uploadData: self._uploadData
+            });
+        },
+
+        setCustomHeaders: function(headers, id) {
+            this._customHeadersStore.set(headers, id);
+        },
+
+        setDeleteFileCustomHeaders: function(headers, id) {
+            this._deleteFileCustomHeadersStore.set(headers, id);
+        },
+
+        setDeleteFileEndpoint: function(endpoint, id) {
+            this._deleteFileEndpointStore.set(endpoint, id);
+        },
+
+        setDeleteFileParams: function(params, id) {
+            this._deleteFileParamsStore.set(params, id);
+        },
+
+        // Re-sets the default endpoint, an endpoint for a specific file, or an endpoint for a specific button
+        setEndpoint: function(endpoint, id) {
+            this._endpointStore.set(endpoint, id);
+        },
+
+        setItemLimit: function(newItemLimit) {
+            this._currentItemLimit = newItemLimit;
+        },
+
+        setName: function(id, newName) {
+            this._uploadData.updateName(id, newName);
+        },
+
+        setParams: function(params, id) {
+            this._paramsStore.set(params, id);
+        },
+
+        setUuid: function(id, newUuid) {
+            return this._uploadData.uuidChanged(id, newUuid);
+        },
+
+        uploadStoredFiles: function() {
+            var idToUpload;
+
+            if (this._storedIds.length === 0) {
+                this._itemError("noFilesError");
+            }
+            else {
+                while (this._storedIds.length) {
+                    idToUpload = this._storedIds.shift();
+                    this._uploadFile(idToUpload);
+                }
+            }
+        }
+    };
+
+    /**
+     * Defines the private (internal) API for FineUploaderBasic mode.
+     */
+    qq.basePrivateApi = {
+        // Updates internal state with a file record (not backed by a live file).  Returns the assigned ID.
+        _addCannedFile: function(sessionData) {
+            var id = this._uploadData.addFile({
+                uuid: sessionData.uuid,
+                name: sessionData.name,
+                size: sessionData.size,
+                status: qq.status.UPLOAD_SUCCESSFUL
+            });
+
+            sessionData.deleteFileEndpoint && this.setDeleteFileEndpoint(sessionData.deleteFileEndpoint, id);
+            sessionData.deleteFileParams && this.setDeleteFileParams(sessionData.deleteFileParams, id);
+
+            if (sessionData.thumbnailUrl) {
+                this._thumbnailUrls[id] = sessionData.thumbnailUrl;
+            }
+
+            this._netUploaded++;
+            this._netUploadedOrQueued++;
+
+            return id;
+        },
+
+        _annotateWithButtonId: function(file, associatedInput) {
+            if (qq.isFile(file)) {
+                file.qqButtonId = this._getButtonId(associatedInput);
+            }
+        },
+
+        _batchError: function(message) {
+            this._options.callbacks.onError(null, null, message, undefined);
+        },
+
+        _createDeleteHandler: function() {
+            var self = this;
+
+            return new qq.DeleteFileAjaxRequester({
+                method: this._options.deleteFile.method.toUpperCase(),
+                maxConnections: this._options.maxConnections,
+                uuidParamName: this._options.request.uuidName,
+                customHeaders: this._deleteFileCustomHeadersStore,
+                paramsStore: this._deleteFileParamsStore,
+                endpointStore: this._deleteFileEndpointStore,
+                cors: this._options.cors,
+                log: qq.bind(self.log, self),
+                onDelete: function(id) {
+                    self._onDelete(id);
+                    self._options.callbacks.onDelete(id);
+                },
+                onDeleteComplete: function(id, xhrOrXdr, isError) {
+                    self._onDeleteComplete(id, xhrOrXdr, isError);
+                    self._options.callbacks.onDeleteComplete(id, xhrOrXdr, isError);
+                }
+
+            });
+        },
+
+        _createPasteHandler: function() {
+            var self = this;
+
+            return new qq.PasteSupport({
+                targetElement: this._options.paste.targetElement,
+                callbacks: {
+                    log: qq.bind(self.log, self),
+                    pasteReceived: function(blob) {
+                        self._handleCheckedCallback({
+                            name: "onPasteReceived",
+                            callback: qq.bind(self._options.callbacks.onPasteReceived, self, blob),
+                            onSuccess: qq.bind(self._handlePasteSuccess, self, blob),
+                            identifier: "pasted image"
+                        });
+                    }
+                }
+            });
+        },
+
+        _createStore: function(initialValue, readOnlyValues) {
+            var store = {},
+                catchall = initialValue,
+                perIdReadOnlyValues = {},
+                copy = function(orig) {
+                    if (qq.isObject(orig)) {
+                        return qq.extend({}, orig);
+                    }
+                    return orig;
+                },
+                getReadOnlyValues = function() {
+                    if (qq.isFunction(readOnlyValues)) {
+                        return readOnlyValues();
+                    }
+                    return readOnlyValues;
+                },
+                includeReadOnlyValues = function(id, existing) {
+                    if (readOnlyValues && qq.isObject(existing)) {
+                        qq.extend(existing, getReadOnlyValues());
+                    }
+
+                    if (perIdReadOnlyValues[id]) {
+                        qq.extend(existing, perIdReadOnlyValues[id]);
+                    }
+                };
+
+            return {
+                set: function(val, id) {
+                    /*jshint eqeqeq: true, eqnull: true*/
+                    if (id == null) {
+                        store = {};
+                        catchall = copy(val);
+                    }
+                    else {
+                        store[id] = copy(val);
+                    }
+                },
+
+                get: function(id) {
+                    var values;
+
+                    /*jshint eqeqeq: true, eqnull: true*/
+                    if (id != null && store[id]) {
+                        values = store[id];
+                    }
+                    else {
+                        values = copy(catchall);
+                    }
+
+                    includeReadOnlyValues(id, values);
+
+                    return copy(values);
+                },
+
+                addReadOnly: function(id, values) {
+                    // Only applicable to Object stores
+                    if (qq.isObject(store)) {
+                        perIdReadOnlyValues[id] = perIdReadOnlyValues[id] || {};
+                        qq.extend(perIdReadOnlyValues[id], values);
+                    }
+                },
+
+                remove: function(fileId) {
+                    return delete store[fileId];
+                },
+
+                reset: function() {
+                    store = {};
+                    perIdReadOnlyValues = {};
+                    catchall = initialValue;
+                }
+            };
+        },
+
+        _createUploadDataTracker: function() {
+            var self = this;
+
+            return new qq.UploadData({
+                getName: function(id) {
+                    return self.getName(id);
+                },
+                getUuid: function(id) {
+                    return self.getUuid(id);
+                },
+                getSize: function(id) {
+                    return self.getSize(id);
+                },
+                onStatusChange: function(id, oldStatus, newStatus) {
+                    self._onUploadStatusChange(id, oldStatus, newStatus);
+                    self._options.callbacks.onStatusChange(id, oldStatus, newStatus);
+                    self._maybeAllComplete(id, newStatus);
+
+                    if (self._totalProgress) {
+                        setTimeout(function() {
+                            self._totalProgress.onStatusChange(id, oldStatus, newStatus);
+                        }, 0);
+                    }
+                }
+            });
+        },
+
+        /**
+         * Generate a tracked upload button.
+         *
+         * @param spec Object containing a required `element` property
+         * along with optional `multiple`, `accept`, and `folders`.
+         * @returns {qq.UploadButton}
+         * @private
+         */
+        _createUploadButton: function(spec) {
+            var self = this,
+                acceptFiles = spec.accept || this._options.validation.acceptFiles,
+                allowedExtensions = spec.allowedExtensions || this._options.validation.allowedExtensions,
+                button;
+
+            function allowMultiple() {
+                if (qq.supportedFeatures.ajaxUploading) {
+                    // Workaround for bug in iOS7+ (see #1039)
+                    if (self._options.workarounds.iosEmptyVideos &&
+                        qq.ios() &&
+                        !qq.ios6() &&
+                        self._isAllowedExtension(allowedExtensions, ".mov")) {
+
+                        return false;
+                    }
+
+                    if (spec.multiple === undefined) {
+                        return self._options.multiple;
+                    }
+
+                    return spec.multiple;
+                }
+
+                return false;
+            }
+
+            button = new qq.UploadButton({
+                element: spec.element,
+                folders: spec.folders,
+                name: this._options.request.inputName,
+                multiple: allowMultiple(),
+                acceptFiles: acceptFiles,
+                onChange: function(input) {
+                    self._onInputChange(input);
+                },
+                hoverClass: this._options.classes.buttonHover,
+                focusClass: this._options.classes.buttonFocus,
+                ios8BrowserCrashWorkaround: this._options.workarounds.ios8BrowserCrash
+            });
+
+            this._disposeSupport.addDisposer(function() {
+                button.dispose();
+            });
+
+            self._buttons.push(button);
+
+            return button;
+        },
+
+        _createUploadHandler: function(additionalOptions, namespace) {
+            var self = this,
+                lastOnProgress = {},
+                options = {
+                    debug: this._options.debug,
+                    maxConnections: this._options.maxConnections,
+                    cors: this._options.cors,
+                    paramsStore: this._paramsStore,
+                    endpointStore: this._endpointStore,
+                    chunking: this._options.chunking,
+                    resume: this._options.resume,
+                    blobs: this._options.blobs,
+                    log: qq.bind(self.log, self),
+                    preventRetryParam: this._options.retry.preventRetryResponseProperty,
+                    onProgress: function(id, name, loaded, total) {
+                        if (loaded < 0 || total < 0) {
+                            return;
+                        }
+
+                        if (lastOnProgress[id]) {
+                            if (lastOnProgress[id].loaded !== loaded || lastOnProgress[id].total !== total) {
+                                self._onProgress(id, name, loaded, total);
+                                self._options.callbacks.onProgress(id, name, loaded, total);
+                            }
+                        }
+                        else {
+                            self._onProgress(id, name, loaded, total);
+                            self._options.callbacks.onProgress(id, name, loaded, total);
+                        }
+
+                        lastOnProgress[id] = {loaded: loaded, total: total};
+
+                    },
+                    onComplete: function(id, name, result, xhr) {
+                        delete lastOnProgress[id];
+
+                        var status = self.getUploads({id: id}).status,
+                            retVal;
+
+                        // This is to deal with some observed cases where the XHR readyStateChange handler is
+                        // invoked by the browser multiple times for the same XHR instance with the same state
+                        // readyState value.  Higher level: don't invoke complete-related code if we've already
+                        // done this.
+                        if (status === qq.status.UPLOAD_SUCCESSFUL || status === qq.status.UPLOAD_FAILED) {
+                            return;
+                        }
+
+                        retVal = self._onComplete(id, name, result, xhr);
+
+                        // If the internal `_onComplete` handler returns a promise, don't invoke the `onComplete` callback
+                        // until the promise has been fulfilled.
+                        if (retVal instanceof  qq.Promise) {
+                            retVal.done(function() {
+                                self._options.callbacks.onComplete(id, name, result, xhr);
+                            });
+                        }
+                        else {
+                            self._options.callbacks.onComplete(id, name, result, xhr);
+                        }
+                    },
+                    onCancel: function(id, name, cancelFinalizationEffort) {
+                        var promise = new qq.Promise();
+
+                        self._handleCheckedCallback({
+                            name: "onCancel",
+                            callback: qq.bind(self._options.callbacks.onCancel, self, id, name),
+                            onFailure: promise.failure,
+                            onSuccess: function() {
+                                cancelFinalizationEffort.then(function() {
+                                    self._onCancel(id, name);
+                                });
+
+                                promise.success();
+                            },
+                            identifier: id
+                        });
+
+                        return promise;
+                    },
+                    onUploadPrep: qq.bind(this._onUploadPrep, this),
+                    onUpload: function(id, name) {
+                        self._onUpload(id, name);
+                        self._options.callbacks.onUpload(id, name);
+                    },
+                    onUploadChunk: function(id, name, chunkData) {
+                        self._onUploadChunk(id, chunkData);
+                        self._options.callbacks.onUploadChunk(id, name, chunkData);
+                    },
+                    onUploadChunkSuccess: function(id, chunkData, result, xhr) {
+                        self._options.callbacks.onUploadChunkSuccess.apply(self, arguments);
+                    },
+                    onResume: function(id, name, chunkData) {
+                        return self._options.callbacks.onResume(id, name, chunkData);
+                    },
+                    onAutoRetry: function(id, name, responseJSON, xhr) {
+                        return self._onAutoRetry.apply(self, arguments);
+                    },
+                    onUuidChanged: function(id, newUuid) {
+                        self.log("Server requested UUID change from '" + self.getUuid(id) + "' to '" + newUuid + "'");
+                        self.setUuid(id, newUuid);
+                    },
+                    getName: qq.bind(self.getName, self),
+                    getUuid: qq.bind(self.getUuid, self),
+                    getSize: qq.bind(self.getSize, self),
+                    setSize: qq.bind(self._setSize, self),
+                    getDataByUuid: function(uuid) {
+                        return self.getUploads({uuid: uuid});
+                    },
+                    isQueued: function(id) {
+                        var status = self.getUploads({id: id}).status;
+                        return status === qq.status.QUEUED ||
+                            status === qq.status.SUBMITTED ||
+                            status === qq.status.UPLOAD_RETRYING ||
+                            status === qq.status.PAUSED;
+                    },
+                    getIdsInProxyGroup: self._uploadData.getIdsInProxyGroup,
+                    getIdsInBatch: self._uploadData.getIdsInBatch
+                };
+
+            qq.each(this._options.request, function(prop, val) {
+                options[prop] = val;
+            });
+
+            options.customHeaders = this._customHeadersStore;
+
+            if (additionalOptions) {
+                qq.each(additionalOptions, function(key, val) {
+                    options[key] = val;
+                });
+            }
+
+            return new qq.UploadHandlerController(options, namespace);
+        },
+
+        _fileOrBlobRejected: function(id) {
+            this._netUploadedOrQueued--;
+            this._uploadData.setStatus(id, qq.status.REJECTED);
+        },
+
+        _formatSize: function(bytes) {
+            var i = -1;
+            do {
+                bytes = bytes / 1000;
+                i++;
+            } while (bytes > 999);
+
+            return Math.max(bytes, 0.1).toFixed(1) + this._options.text.sizeSymbols[i];
+        },
+
+        // Creates an internal object that tracks various properties of each extra button,
+        // and then actually creates the extra button.
+        _generateExtraButtonSpecs: function() {
+            var self = this;
+
+            this._extraButtonSpecs = {};
+
+            qq.each(this._options.extraButtons, function(idx, extraButtonOptionEntry) {
+                var multiple = extraButtonOptionEntry.multiple,
+                    validation = qq.extend({}, self._options.validation, true),
+                    extraButtonSpec = qq.extend({}, extraButtonOptionEntry);
+
+                if (multiple === undefined) {
+                    multiple = self._options.multiple;
+                }
+
+                if (extraButtonSpec.validation) {
+                    qq.extend(validation, extraButtonOptionEntry.validation, true);
+                }
+
+                qq.extend(extraButtonSpec, {
+                    multiple: multiple,
+                    validation: validation
+                }, true);
+
+                self._initExtraButton(extraButtonSpec);
+            });
+        },
+
+        _getButton: function(buttonId) {
+            var extraButtonsSpec = this._extraButtonSpecs[buttonId];
+
+            if (extraButtonsSpec) {
+                return extraButtonsSpec.element;
+            }
+            else if (buttonId === this._defaultButtonId) {
+                return this._options.button;
+            }
+        },
+
+        /**
+         * Gets the internally used tracking ID for a button.
+         *
+         * @param buttonOrFileInputOrFile `File`, `<input type="file">`, or a button container element
+         * @returns {*} The button's ID, or undefined if no ID is recoverable
+         * @private
+         */
+        _getButtonId: function(buttonOrFileInputOrFile) {
+            var inputs, fileInput,
+                fileBlobOrInput = buttonOrFileInputOrFile;
+
+            // We want the reference file/blob here if this is a proxy (a file that will be generated on-demand later)
+            if (fileBlobOrInput instanceof qq.BlobProxy) {
+                fileBlobOrInput = fileBlobOrInput.referenceBlob;
+            }
+
+            // If the item is a `Blob` it will never be associated with a button or drop zone.
+            if (fileBlobOrInput && !qq.isBlob(fileBlobOrInput)) {
+                if (qq.isFile(fileBlobOrInput)) {
+                    return fileBlobOrInput.qqButtonId;
+                }
+                else if (fileBlobOrInput.tagName.toLowerCase() === "input" &&
+                    fileBlobOrInput.type.toLowerCase() === "file") {
+
+                    return fileBlobOrInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);
+                }
+
+                inputs = fileBlobOrInput.getElementsByTagName("input");
+
+                qq.each(inputs, function(idx, input) {
+                    if (input.getAttribute("type") === "file") {
+                        fileInput = input;
+                        return false;
+                    }
+                });
+
+                if (fileInput) {
+                    return fileInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);
+                }
+            }
+        },
+
+        _getNotFinished: function() {
+            return this._uploadData.retrieve({
+                status: [
+                    qq.status.UPLOADING,
+                    qq.status.UPLOAD_RETRYING,
+                    qq.status.QUEUED,
+                    qq.status.SUBMITTING,
+                    qq.status.SUBMITTED,
+                    qq.status.PAUSED
+                ]
+            }).length;
+        },
+
+        // Get the validation options for this button.  Could be the default validation option
+        // or a specific one assigned to this particular button.
+        _getValidationBase: function(buttonId) {
+            var extraButtonSpec = this._extraButtonSpecs[buttonId];
+
+            return extraButtonSpec ? extraButtonSpec.validation : this._options.validation;
+        },
+
+        _getValidationDescriptor: function(fileWrapper) {
+            if (fileWrapper.file instanceof qq.BlobProxy) {
+                return {
+                    name: qq.getFilename(fileWrapper.file.referenceBlob),
+                    size: fileWrapper.file.referenceBlob.size
+                };
+            }
+
+            return {
+                name: this.getUploads({id: fileWrapper.id}).name,
+                size: this.getUploads({id: fileWrapper.id}).size
+            };
+        },
+
+        _getValidationDescriptors: function(fileWrappers) {
+            var self = this,
+                fileDescriptors = [];
+
+            qq.each(fileWrappers, function(idx, fileWrapper) {
+                fileDescriptors.push(self._getValidationDescriptor(fileWrapper));
+            });
+
+            return fileDescriptors;
+        },
+
+        // Allows camera access on either the default or an extra button for iOS devices.
+        _handleCameraAccess: function() {
+            if (this._options.camera.ios && qq.ios()) {
+                var acceptIosCamera = "image/*;capture=camera",
+                    button = this._options.camera.button,
+                    buttonId = button ? this._getButtonId(button) : this._defaultButtonId,
+                    optionRoot = this._options;
+
+                // If we are not targeting the default button, it is an "extra" button
+                if (buttonId && buttonId !== this._defaultButtonId) {
+                    optionRoot = this._extraButtonSpecs[buttonId];
+                }
+
+                // Camera access won't work in iOS if the `multiple` attribute is present on the file input
+                optionRoot.multiple = false;
+
+                // update the options
+                if (optionRoot.validation.acceptFiles === null) {
+                    optionRoot.validation.acceptFiles = acceptIosCamera;
+                }
+                else {
+                    optionRoot.validation.acceptFiles += "," + acceptIosCamera;
+                }
+
+                // update the already-created button
+                qq.each(this._buttons, function(idx, button) {
+                    if (button.getButtonId() === buttonId) {
+                        button.setMultiple(optionRoot.multiple);
+                        button.setAcceptFiles(optionRoot.acceptFiles);
+
+                        return false;
+                    }
+                });
+            }
+        },
+
+        _handleCheckedCallback: function(details) {
+            var self = this,
+                callbackRetVal = details.callback();
+
+            if (qq.isGenericPromise(callbackRetVal)) {
+                this.log(details.name + " - waiting for " + details.name + " promise to be fulfilled for " + details.identifier);
+                return callbackRetVal.then(
+                    function(successParam) {
+                        self.log(details.name + " promise success for " + details.identifier);
+                        details.onSuccess(successParam);
+                    },
+                    function() {
+                        if (details.onFailure) {
+                            self.log(details.name + " promise failure for " + details.identifier);
+                            details.onFailure();
+                        }
+                        else {
+                            self.log(details.name + " promise failure for " + details.identifier);
+                        }
+                    });
+            }
+
+            if (callbackRetVal !== false) {
+                details.onSuccess(callbackRetVal);
+            }
+            else {
+                if (details.onFailure) {
+                    this.log(details.name + " - return value was 'false' for " + details.identifier + ".  Invoking failure callback.");
+                    details.onFailure();
+                }
+                else {
+                    this.log(details.name + " - return value was 'false' for " + details.identifier + ".  Will not proceed.");
+                }
+            }
+
+            return callbackRetVal;
+        },
+
+        // Updates internal state when a new file has been received, and adds it along with its ID to a passed array.
+        _handleNewFile: function(file, batchId, newFileWrapperList) {
+            var self = this,
+                uuid = qq.getUniqueId(),
+                size = -1,
+                name = qq.getFilename(file),
+                actualFile = file.blob || file,
+                handler = this._customNewFileHandler ?
+                    this._customNewFileHandler :
+                    qq.bind(self._handleNewFileGeneric, self);
+
+            if (!qq.isInput(actualFile) && actualFile.size >= 0) {
+                size = actualFile.size;
+            }
+
+            handler(actualFile, name, uuid, size, newFileWrapperList, batchId, this._options.request.uuidName, {
+                uploadData: self._uploadData,
+                paramsStore: self._paramsStore,
+                addFileToHandler: function(id, file) {
+                    self._handler.add(id, file);
+                    self._netUploadedOrQueued++;
+                    self._trackButton(id);
+                }
+            });
+        },
+
+        _handleNewFileGeneric: function(file, name, uuid, size, fileList, batchId) {
+            var id = this._uploadData.addFile({uuid: uuid, name: name, size: size, batchId: batchId});
+
+            this._handler.add(id, file);
+            this._trackButton(id);
+
+            this._netUploadedOrQueued++;
+
+            fileList.push({id: id, file: file});
+        },
+
+        _handlePasteSuccess: function(blob, extSuppliedName) {
+            var extension = blob.type.split("/")[1],
+                name = extSuppliedName;
+
+            /*jshint eqeqeq: true, eqnull: true*/
+            if (name == null) {
+                name = this._options.paste.defaultName;
+            }
+
+            name += "." + extension;
+
+            this.addFiles({
+                name: name,
+                blob: blob
+            });
+        },
+
+        // Creates an extra button element
+        _initExtraButton: function(spec) {
+            var button = this._createUploadButton({
+                element: spec.element,
+                multiple: spec.multiple,
+                accept: spec.validation.acceptFiles,
+                folders: spec.folders,
+                allowedExtensions: spec.validation.allowedExtensions
+            });
+
+            this._extraButtonSpecs[button.getButtonId()] = spec;
+        },
+
+        _initFormSupportAndParams: function() {
+            this._formSupport = qq.FormSupport && new qq.FormSupport(
+                this._options.form, qq.bind(this.uploadStoredFiles, this), qq.bind(this.log, this)
+            );
+
+            if (this._formSupport && this._formSupport.attachedToForm) {
+                this._paramsStore = this._createStore(
+                    this._options.request.params,  this._formSupport.getFormInputsAsObject
+                );
+
+                this._options.autoUpload = this._formSupport.newAutoUpload;
+                if (this._formSupport.newEndpoint) {
+                    this._options.request.endpoint = this._formSupport.newEndpoint;
+                }
+            }
+            else {
+                this._paramsStore = this._createStore(this._options.request.params);
+            }
+        },
+
+        _isDeletePossible: function() {
+            if (!qq.DeleteFileAjaxRequester || !this._options.deleteFile.enabled) {
+                return false;
+            }
+
+            if (this._options.cors.expected) {
+                if (qq.supportedFeatures.deleteFileCorsXhr) {
+                    return true;
+                }
+
+                if (qq.supportedFeatures.deleteFileCorsXdr && this._options.cors.allowXdr) {
+                    return true;
+                }
+
+                return false;
+            }
+
+            return true;
+        },
+
+        _isAllowedExtension: function(allowed, fileName) {
+            var valid = false;
+
+            if (!allowed.length) {
+                return true;
+            }
+
+            qq.each(allowed, function(idx, allowedExt) {
+                /**
+                 * If an argument is not a string, ignore it.  Added when a possible issue with MooTools hijacking the
+                 * `allowedExtensions` array was discovered.  See case #735 in the issue tracker for more details.
+                 */
+                if (qq.isString(allowedExt)) {
+                    /*jshint eqeqeq: true, eqnull: true*/
+                    var extRegex = new RegExp("\\." + allowedExt + "$", "i");
+
+                    if (fileName.match(extRegex) != null) {
+                        valid = true;
+                        return false;
+                    }
+                }
+            });
+
+            return valid;
+        },
+
+        /**
+         * Constructs and returns a message that describes an item/file error.  Also calls `onError` callback.
+         *
+         * @param code REQUIRED - a code that corresponds to a stock message describing this type of error
+         * @param maybeNameOrNames names of the items that have failed, if applicable
+         * @param item `File`, `Blob`, or `<input type="file">`
+         * @private
+         */
+        _itemError: function(code, maybeNameOrNames, item) {
+            var message = this._options.messages[code],
+                allowedExtensions = [],
+                names = [].concat(maybeNameOrNames),
+                name = names[0],
+                buttonId = this._getButtonId(item),
+                validationBase = this._getValidationBase(buttonId),
+                extensionsForMessage, placeholderMatch;
+
+            function r(name, replacement) { message = message.replace(name, replacement); }
+
+            qq.each(validationBase.allowedExtensions, function(idx, allowedExtension) {
+                /**
+                 * If an argument is not a string, ignore it.  Added when a possible issue with MooTools hijacking the
+                 * `allowedExtensions` array was discovered.  See case #735 in the issue tracker for more details.
+                 */
+                if (qq.isString(allowedExtension)) {
+                    allowedExtensions.push(allowedExtension);
+                }
+            });
+
+            extensionsForMessage = allowedExtensions.join(", ").toLowerCase();
+
+            r("{file}", this._options.formatFileName(name));
+            r("{extensions}", extensionsForMessage);
+            r("{sizeLimit}", this._formatSize(validationBase.sizeLimit));
+            r("{minSizeLimit}", this._formatSize(validationBase.minSizeLimit));
+
+            placeholderMatch = message.match(/(\{\w+\})/g);
+            if (placeholderMatch !== null) {
+                qq.each(placeholderMatch, function(idx, placeholder) {
+                    r(placeholder, names[idx]);
+                });
+            }
+
+            this._options.callbacks.onError(null, name, message, undefined);
+
+            return message;
+        },
+
+        /**
+         * Conditionally orders a manual retry of a failed upload.
+         *
+         * @param id File ID of the failed upload
+         * @param callback Optional callback to invoke if a retry is prudent.
+         * In lieu of asking the upload handler to retry.
+         * @returns {boolean} true if a manual retry will occur
+         * @private
+         */
+        _manualRetry: function(id, callback) {
+            if (this._onBeforeManualRetry(id)) {
+                this._netUploadedOrQueued++;
+                this._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);
+
+                if (callback) {
+                    callback(id);
+                }
+                else {
+                    this._handler.retry(id);
+                }
+
+                return true;
+            }
+        },
+
+        _maybeAllComplete: function(id, status) {
+            var self = this,
+                notFinished = this._getNotFinished();
+
+            if (status === qq.status.UPLOAD_SUCCESSFUL) {
+                this._succeededSinceLastAllComplete.push(id);
+            }
+            else if (status === qq.status.UPLOAD_FAILED) {
+                this._failedSinceLastAllComplete.push(id);
+            }
+
+            if (notFinished === 0 &&
+                (this._succeededSinceLastAllComplete.length || this._failedSinceLastAllComplete.length)) {
+                // Attempt to ensure onAllComplete is not invoked before other callbacks, such as onCancel & onComplete
+                setTimeout(function() {
+                    self._onAllComplete(self._succeededSinceLastAllComplete, self._failedSinceLastAllComplete);
+                }, 0);
+            }
+        },
+
+        _maybeHandleIos8SafariWorkaround: function() {
+            var self = this;
+
+            if (this._options.workarounds.ios8SafariUploads && qq.ios800() && qq.iosSafari()) {
+                setTimeout(function() {
+                    window.alert(self._options.messages.unsupportedBrowserIos8Safari);
+                }, 0);
+                throw new qq.Error(this._options.messages.unsupportedBrowserIos8Safari);
+            }
+        },
+
+        _maybeParseAndSendUploadError: function(id, name, response, xhr) {
+            // Assuming no one will actually set the response code to something other than 200
+            // and still set 'success' to true...
+            if (!response.success) {
+                if (xhr && xhr.status !== 200 && !response.error) {
+                    this._options.callbacks.onError(id, name, "XHR returned response code " + xhr.status, xhr);
+                }
+                else {
+                    var errorReason = response.error ? response.error : this._options.text.defaultResponseError;
+                    this._options.callbacks.onError(id, name, errorReason, xhr);
+                }
+            }
+        },
+
+        _maybeProcessNextItemAfterOnValidateCallback: function(validItem, items, index, params, endpoint) {
+            var self = this;
+
+            if (items.length > index) {
+                if (validItem || !this._options.validation.stopOnFirstInvalidFile) {
+                    //use setTimeout to prevent a stack overflow with a large number of files in the batch & non-promissory callbacks
+                    setTimeout(function() {
+                        var validationDescriptor = self._getValidationDescriptor(items[index]),
+                            buttonId = self._getButtonId(items[index].file),
+                            button = self._getButton(buttonId);
+
+                        self._handleCheckedCallback({
+                            name: "onValidate",
+                            callback: qq.bind(self._options.callbacks.onValidate, self, validationDescriptor, button),
+                            onSuccess: qq.bind(self._onValidateCallbackSuccess, self, items, index, params, endpoint),
+                            onFailure: qq.bind(self._onValidateCallbackFailure, self, items, index, params, endpoint),
+                            identifier: "Item '" + validationDescriptor.name + "', size: " + validationDescriptor.size
+                        });
+                    }, 0);
+                }
+                else if (!validItem) {
+                    for (; index < items.length; index++) {
+                        self._fileOrBlobRejected(items[index].id);
+                    }
+                }
+            }
+        },
+
+        _onAllComplete: function(successful, failed) {
+            this._totalProgress && this._totalProgress.onAllComplete(successful, failed, this._preventRetries);
+
+            this._options.callbacks.onAllComplete(qq.extend([], successful), qq.extend([], failed));
+
+            this._succeededSinceLastAllComplete = [];
+            this._failedSinceLastAllComplete = [];
+        },
+
+        /**
+         * Attempt to automatically retry a failed upload.
+         *
+         * @param id The file ID of the failed upload
+         * @param name The name of the file associated with the failed upload
+         * @param responseJSON Response from the server, parsed into a javascript object
+         * @param xhr Ajax transport used to send the failed request
+         * @param callback Optional callback to be invoked if a retry is prudent.
+         * Invoked in lieu of asking the upload handler to retry.
+         * @returns {boolean} true if an auto-retry will occur
+         * @private
+         */
+        _onAutoRetry: function(id, name, responseJSON, xhr, callback) {
+            var self = this;
+
+            self._preventRetries[id] = responseJSON[self._options.retry.preventRetryResponseProperty];
+
+            if (self._shouldAutoRetry(id, name, responseJSON)) {
+                self._maybeParseAndSendUploadError.apply(self, arguments);
+                self._options.callbacks.onAutoRetry(id, name, self._autoRetries[id]);
+                self._onBeforeAutoRetry(id, name);
+
+                self._retryTimeouts[id] = setTimeout(function() {
+                    self.log("Retrying " + name + "...");
+                    self._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);
+
+                    if (callback) {
+                        callback(id);
+                    }
+                    else {
+                        self._handler.retry(id);
+                    }
+                }, self._options.retry.autoAttemptDelay * 1000);
+
+                return true;
+            }
+        },
+
+        _onBeforeAutoRetry: function(id, name) {
+            this.log("Waiting " + this._options.retry.autoAttemptDelay + " seconds before retrying " + name + "...");
+        },
+
+        //return false if we should not attempt the requested retry
+        _onBeforeManualRetry: function(id) {
+            var itemLimit = this._currentItemLimit,
+                fileName;
+            console.log(this._handler.isValid(id));
+            if (this._preventRetries[id]) {
+                this.log("Retries are forbidden for id " + id, "warn");
+                return false;
+            }
+            else if (this._handler.isValid(id)) {
+                fileName = this.getName(id);
+
+                if (this._options.callbacks.onManualRetry(id, fileName) === false) {
+                    return false;
+                }
+
+                if (itemLimit > 0 && this._netUploadedOrQueued + 1 > itemLimit) {
+                    this._itemError("retryFailTooManyItems");
+                    return false;
+                }
+
+                this.log("Retrying upload for '" + fileName + "' (id: " + id + ")...");
+                return true;
+            }
+            else {
+                this.log("'" + id + "' is not a valid file ID", "error");
+                return false;
+            }
+        },
+
+        _onCancel: function(id, name) {
+            this._netUploadedOrQueued--;
+
+            clearTimeout(this._retryTimeouts[id]);
+
+            var storedItemIndex = qq.indexOf(this._storedIds, id);
+            if (!this._options.autoUpload && storedItemIndex >= 0) {
+                this._storedIds.splice(storedItemIndex, 1);
+            }
+
+            this._uploadData.setStatus(id, qq.status.CANCELED);
+        },
+
+        _onComplete: function(id, name, result, xhr) {
+            if (!result.success) {
+                this._netUploadedOrQueued--;
+                this._uploadData.setStatus(id, qq.status.UPLOAD_FAILED);
+
+                if (result[this._options.retry.preventRetryResponseProperty] === true) {
+                    this._preventRetries[id] = true;
+                }
+            }
+            else {
+                if (result.thumbnailUrl) {
+                    this._thumbnailUrls[id] = result.thumbnailUrl;
+                }
+
+                this._netUploaded++;
+                this._uploadData.setStatus(id, qq.status.UPLOAD_SUCCESSFUL);
+            }
+
+            this._maybeParseAndSendUploadError(id, name, result, xhr);
+
+            return result.success ? true : false;
+        },
+
+        _onDelete: function(id) {
+            this._uploadData.setStatus(id, qq.status.DELETING);
+        },
+
+        _onDeleteComplete: function(id, xhrOrXdr, isError) {
+            var name = this.getName(id);
+
+            if (isError) {
+                this._uploadData.setStatus(id, qq.status.DELETE_FAILED);
+                this.log("Delete request for '" + name + "' has failed.", "error");
+
+                // For error reporing, we only have accesss to the response status if this is not
+                // an `XDomainRequest`.
+                if (xhrOrXdr.withCredentials === undefined) {
+                    this._options.callbacks.onError(id, name, "Delete request failed", xhrOrXdr);
+                }
+                else {
+                    this._options.callbacks.onError(id, name, "Delete request failed with response code " + xhrOrXdr.status, xhrOrXdr);
+                }
+            }
+            else {
+                this._netUploadedOrQueued--;
+                this._netUploaded--;
+                this._handler.expunge(id);
+                this._uploadData.setStatus(id, qq.status.DELETED);
+                this.log("Delete request for '" + name + "' has succeeded.");
+            }
+        },
+
+        _onInputChange: function(input) {
+            var fileIndex;
+
+            if (qq.supportedFeatures.ajaxUploading) {
+                for (fileIndex = 0; fileIndex < input.files.length; fileIndex++) {
+                    this._annotateWithButtonId(input.files[fileIndex], input);
+                }
+
+                this.addFiles(input.files);
+            }
+            // Android 2.3.x will fire `onchange` even if no file has been selected
+            else if (input.value.length > 0) {
+                this.addFiles(input);
+            }
+
+            qq.each(this._buttons, function(idx, button) {
+                button.reset();
+            });
+        },
+
+        _onProgress: function(id, name, loaded, total) {
+            this._totalProgress && this._totalProgress.onIndividualProgress(id, loaded, total);
+        },
+
+        _onSubmit: function(id, name) {
+            //nothing to do yet in core uploader
+        },
+
+        _onSubmitCallbackSuccess: function(id, name) {
+            this._onSubmit.apply(this, arguments);
+            this._uploadData.setStatus(id, qq.status.SUBMITTED);
+            this._onSubmitted.apply(this, arguments);
+            this._options.callbacks.onSubmitted.apply(this, arguments);
+
+            if (this._options.autoUpload) {
+                this._uploadFile(id);
+            }
+            else {
+                this._storeForLater(id);
+            }
+        },
+
+        _onSubmitDelete: function(id, onSuccessCallback, additionalMandatedParams) {
+            var uuid = this.getUuid(id),
+                adjustedOnSuccessCallback;
+
+            if (onSuccessCallback) {
+                adjustedOnSuccessCallback = qq.bind(onSuccessCallback, this, id, uuid, additionalMandatedParams);
+            }
+
+            if (this._isDeletePossible()) {
+                this._handleCheckedCallback({
+                    name: "onSubmitDelete",
+                    callback: qq.bind(this._options.callbacks.onSubmitDelete, this, id),
+                    onSuccess: adjustedOnSuccessCallback ||
+                        qq.bind(this._deleteHandler.sendDelete, this, id, uuid, additionalMandatedParams),
+                    identifier: id
+                });
+                return true;
+            }
+            else {
+                this.log("Delete request ignored for ID " + id + ", delete feature is disabled or request not possible " +
+                    "due to CORS on a user agent that does not support pre-flighting.", "warn");
+                return false;
+            }
+        },
+
+        _onSubmitted: function(id) {
+            //nothing to do in the base uploader
+        },
+
+        _onTotalProgress: function(loaded, total) {
+            this._options.callbacks.onTotalProgress(loaded, total);
+        },
+
+        _onUploadPrep: function(id) {
+            // nothing to do in the core uploader for now
+        },
+
+        _onUpload: function(id, name) {
+            this._uploadData.setStatus(id, qq.status.UPLOADING);
+        },
+
+        _onUploadChunk: function(id, chunkData) {
+            //nothing to do in the base uploader
+        },
+
+        _onUploadStatusChange: function(id, oldStatus, newStatus) {
+            // Make sure a "queued" retry attempt is canceled if the upload has been paused
+            if (newStatus === qq.status.PAUSED) {
+                clearTimeout(this._retryTimeouts[id]);
+            }
+        },
+
+        _onValidateBatchCallbackFailure: function(fileWrappers) {
+            var self = this;
+
+            qq.each(fileWrappers, function(idx, fileWrapper) {
+                self._fileOrBlobRejected(fileWrapper.id);
+            });
+        },
+
+        _onValidateBatchCallbackSuccess: function(validationDescriptors, items, params, endpoint, button) {
+            var errorMessage,
+                itemLimit = this._currentItemLimit,
+                proposedNetFilesUploadedOrQueued = this._netUploadedOrQueued;
+
+            if (itemLimit === 0 || proposedNetFilesUploadedOrQueued <= itemLimit) {
+                if (items.length > 0) {
+                    this._handleCheckedCallback({
+                        name: "onValidate",
+                        callback: qq.bind(this._options.callbacks.onValidate, this, validationDescriptors[0], button),
+                        onSuccess: qq.bind(this._onValidateCallbackSuccess, this, items, 0, params, endpoint),
+                        onFailure: qq.bind(this._onValidateCallbackFailure, this, items, 0, params, endpoint),
+                        identifier: "Item '" + items[0].file.name + "', size: " + items[0].file.size
+                    });
+                }
+                else {
+                    this._itemError("noFilesError");
+                }
+            }
+            else {
+                this._onValidateBatchCallbackFailure(items);
+                errorMessage = this._options.messages.tooManyItemsError
+                    .replace(/\{netItems\}/g, proposedNetFilesUploadedOrQueued)
+                    .replace(/\{itemLimit\}/g, itemLimit);
+                this._batchError(errorMessage);
+            }
+        },
+
+        _onValidateCallbackFailure: function(items, index, params, endpoint) {
+            var nextIndex = index + 1;
+
+            this._fileOrBlobRejected(items[index].id, items[index].file.name);
+
+            this._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);
+        },
+
+        _onValidateCallbackSuccess: function(items, index, params, endpoint) {
+            var self = this,
+                nextIndex = index + 1,
+                validationDescriptor = this._getValidationDescriptor(items[index]);
+
+            this._validateFileOrBlobData(items[index], validationDescriptor)
+                .then(
+                function() {
+                    self._upload(items[index].id, params, endpoint);
+                    self._maybeProcessNextItemAfterOnValidateCallback(true, items, nextIndex, params, endpoint);
+                },
+                function() {
+                    self._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);
+                }
+            );
+        },
+
+        _prepareItemsForUpload: function(items, params, endpoint) {
+            if (items.length === 0) {
+                this._itemError("noFilesError");
+                return;
+            }
+
+            var validationDescriptors = this._getValidationDescriptors(items),
+                buttonId = this._getButtonId(items[0].file),
+                button = this._getButton(buttonId);
+
+            this._handleCheckedCallback({
+                name: "onValidateBatch",
+                callback: qq.bind(this._options.callbacks.onValidateBatch, this, validationDescriptors, button),
+                onSuccess: qq.bind(this._onValidateBatchCallbackSuccess, this, validationDescriptors, items, params, endpoint, button),
+                onFailure: qq.bind(this._onValidateBatchCallbackFailure, this, items),
+                identifier: "batch validation"
+            });
+        },
+
+        _preventLeaveInProgress: function() {
+            var self = this;
+
+            this._disposeSupport.attach(window, "beforeunload", function(e) {
+                if (self.getInProgress()) {
+                    e = e || window.event;
+                    // for ie, ff
+                    e.returnValue = self._options.messages.onLeave;
+                    // for webkit
+                    return self._options.messages.onLeave;
+                }
+            });
+        },
+
+        // Attempts to refresh session data only if the `qq.Session` module exists
+        // and a session endpoint has been specified.  The `onSessionRequestComplete`
+        // callback will be invoked once the refresh is complete.
+        _refreshSessionData: function() {
+            var self = this,
+                options = this._options.session;
+
+            /* jshint eqnull:true */
+            if (qq.Session && this._options.session.endpoint != null) {
+                if (!this._session) {
+                    qq.extend(options, this._options.cors);
+
+                    options.log = qq.bind(this.log, this);
+                    options.addFileRecord = qq.bind(this._addCannedFile, this);
+
+                    this._session = new qq.Session(options);
+                }
+
+                setTimeout(function() {
+                    self._session.refresh().then(function(response, xhrOrXdr) {
+
+                        self._options.callbacks.onSessionRequestComplete(response, true, xhrOrXdr);
+
+                    }, function(response, xhrOrXdr) {
+
+                        self._options.callbacks.onSessionRequestComplete(response, false, xhrOrXdr);
+                    });
+                }, 0);
+            }
+        },
+
+        _setSize: function(id, newSize) {
+            this._uploadData.updateSize(id, newSize);
+            this._totalProgress && this._totalProgress.onNewSize(id);
+        },
+
+        _shouldAutoRetry: function(id, name, responseJSON) {
+            var uploadData = this._uploadData.retrieve({id: id});
+
+            /*jshint laxbreak: true */
+            if (!this._preventRetries[id]
+                && this._options.retry.enableAuto
+                && uploadData.status !== qq.status.PAUSED) {
+
+                if (this._autoRetries[id] === undefined) {
+                    this._autoRetries[id] = 0;
+                }
+
+                if (this._autoRetries[id] < this._options.retry.maxAutoAttempts) {
+                    this._autoRetries[id] += 1;
+                    return true;
+                }
+            }
+
+            return false;
+        },
+
+        _storeForLater: function(id) {
+            this._storedIds.push(id);
+        },
+
+        // Maps a file with the button that was used to select it.
+        _trackButton: function(id) {
+            var buttonId;
+
+            if (qq.supportedFeatures.ajaxUploading) {
+                buttonId = this._handler.getFile(id).qqButtonId;
+            }
+            else {
+                buttonId = this._getButtonId(this._handler.getInput(id));
+            }
+
+            if (buttonId) {
+                this._buttonIdsForFileIds[id] = buttonId;
+            }
+        },
+
+        _upload: function(id, params, endpoint) {
+            var name = this.getName(id);
+
+            if (params) {
+                this.setParams(params, id);
+            }
+
+            if (endpoint) {
+                this.setEndpoint(endpoint, id);
+            }
+
+            this._handleCheckedCallback({
+                name: "onSubmit",
+                callback: qq.bind(this._options.callbacks.onSubmit, this, id, name),
+                onSuccess: qq.bind(this._onSubmitCallbackSuccess, this, id, name),
+                onFailure: qq.bind(this._fileOrBlobRejected, this, id, name),
+                identifier: id
+            });
+        },
+
+        _uploadFile: function(id) {
+            if (!this._handler.upload(id)) {
+                this._uploadData.setStatus(id, qq.status.QUEUED);
+            }
+        },
+
+        /**
+         * Performs some internal validation checks on an item, defined in the `validation` option.
+         *
+         * @param fileWrapper Wrapper containing a `file` along with an `id`
+         * @param validationDescriptor Normalized information about the item (`size`, `name`).
+         * @returns qq.Promise with appropriate callbacks invoked depending on the validity of the file
+         * @private
+         */
+        _validateFileOrBlobData: function(fileWrapper, validationDescriptor) {
+            var self = this,
+                file = (function() {
+                    if (fileWrapper.file instanceof qq.BlobProxy) {
+                        return fileWrapper.file.referenceBlob;
+                    }
+                    return fileWrapper.file;
+                }()),
+                name = validationDescriptor.name,
+                size = validationDescriptor.size,
+                buttonId = this._getButtonId(fileWrapper.file),
+                validationBase = this._getValidationBase(buttonId),
+                validityChecker = new qq.Promise();
+
+            validityChecker.then(
+                function() {},
+                function() {
+                    self._fileOrBlobRejected(fileWrapper.id, name);
+                });
+
+            if (qq.isFileOrInput(file) && !this._isAllowedExtension(validationBase.allowedExtensions, name)) {
+                this._itemError("typeError", name, file);
+                return validityChecker.failure();
+            }
+
+            if (size === 0) {
+                this._itemError("emptyError", name, file);
+                return validityChecker.failure();
+            }
+
+            if (size > 0 && validationBase.sizeLimit && size > validationBase.sizeLimit) {
+                this._itemError("sizeError", name, file);
+                return validityChecker.failure();
+            }
+
+            if (size > 0 && size < validationBase.minSizeLimit) {
+                this._itemError("minSizeError", name, file);
+                return validityChecker.failure();
+            }
+
+            if (qq.ImageValidation && qq.supportedFeatures.imagePreviews && qq.isFile(file)) {
+                new qq.ImageValidation(file, qq.bind(self.log, self)).validate(validationBase.image).then(
+                    validityChecker.success,
+                    function(errorCode) {
+                        self._itemError(errorCode + "ImageError", name, file);
+                        validityChecker.failure();
+                    }
+                );
+            }
+            else {
+                validityChecker.success();
+            }
+
+            return validityChecker;
+        },
+
+        _wrapCallbacks: function() {
+            var self, safeCallback, prop;
+
+            self = this;
+
+            safeCallback = function(name, callback, args) {
+                var errorMsg;
+
+                try {
+                    return callback.apply(self, args);
+                }
+                catch (exception) {
+                    errorMsg = exception.message || exception.toString();
+                    self.log("Caught exception in '" + name + "' callback - " + errorMsg, "error");
+                }
+            };
+
+            /* jshint forin: false, loopfunc: true */
+            for (prop in this._options.callbacks) {
+                (function() {
+                    var callbackName, callbackFunc;
+                    callbackName = prop;
+                    callbackFunc = self._options.callbacks[callbackName];
+                    self._options.callbacks[callbackName] = function() {
+                        return safeCallback(callbackName, callbackFunc, arguments);
+                    };
+                }());
+            }
+        }
+    };
+}());
+
+/*globals qq*/
+(function() {
+    "use strict";
+
+    qq.FineUploaderBasic = function(o) {
+        var self = this;
+
+        // These options define FineUploaderBasic mode.
+        this._options = {
+            debug: false,
+            button: null,
+            multiple: true,
+            maxConnections: 3,
+            disableCancelForFormUploads: false,
+            autoUpload: true,
+
+            request: {
+                customHeaders: {},
+                endpoint: "/server/upload",
+                filenameParam: "qqfilename",
+                forceMultipart: true,
+                inputName: "qqfile",
+                method: "POST",
+                params: {},
+                paramsInBody: true,
+                totalFileSizeName: "qqtotalfilesize",
+                uuidName: "qquuid"
+            },
+
+            validation: {
+                allowedExtensions: [],
+                sizeLimit: 0,
+                minSizeLimit: 0,
+                itemLimit: 0,
+                stopOnFirstInvalidFile: true,
+                acceptFiles: null,
+                image: {
+                    maxHeight: 0,
+                    maxWidth: 0,
+                    minHeight: 0,
+                    minWidth: 0
+                }
+            },
+
+            callbacks: {
+                onSubmit: function(id, name) {},
+                onSubmitted: function(id, name) {},
+                onComplete: function(id, name, responseJSON, maybeXhr) {},
+                onAllComplete: function(successful, failed) {},
+                onCancel: function(id, name) {},
+                onUpload: function(id, name) {},
+                onUploadChunk: function(id, name, chunkData) {},
+                onUploadChunkSuccess: function(id, chunkData, responseJSON, xhr) {},
+                onResume: function(id, fileName, chunkData) {},
+                onProgress: function(id, name, loaded, total) {},
+                onTotalProgress: function(loaded, total) {},
+                onError: function(id, name, reason, maybeXhrOrXdr) {},
+                onAutoRetry: function(id, name, attemptNumber) {},
+                onManualRetry: function(id, name) {},
+                onValidateBatch: function(fileOrBlobData) {},
+                onValidate: function(fileOrBlobData) {},
+                onSubmitDelete: function(id) {},
+                onDelete: function(id) {},
+                onDeleteComplete: function(id, xhrOrXdr, isError) {},
+                onPasteReceived: function(blob) {},
+                onStatusChange: function(id, oldStatus, newStatus) {},
+                onSessionRequestComplete: function(response, success, xhrOrXdr) {}
+            },
+
+            messages: {
+                typeError: "{file} has an invalid extension. Valid extension(s): {extensions}.",
+                sizeError: "{file} is too large, maximum file size is {sizeLimit}.",
+                minSizeError: "{file} is too small, minimum file size is {minSizeLimit}.",
+                emptyError: "{file} is empty, please select files again without it.",
+                noFilesError: "No files to upload.",
+                tooManyItemsError: "Too many items ({netItems}) would be uploaded.  Item limit is {itemLimit}.",
+                maxHeightImageError: "Image is too tall.",
+                maxWidthImageError: "Image is too wide.",
+                minHeightImageError: "Image is not tall enough.",
+                minWidthImageError: "Image is not wide enough.",
+                retryFailTooManyItems: "Retry failed - you have reached your file limit.",
+                onLeave: "The files are being uploaded, if you leave now the upload will be canceled.",
+                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."
+            },
+
+            retry: {
+                enableAuto: false,
+                maxAutoAttempts: 3,
+                autoAttemptDelay: 5,
+                preventRetryResponseProperty: "preventRetry"
+            },
+
+            classes: {
+                buttonHover: "qq-upload-button-hover",
+                buttonFocus: "qq-upload-button-focus"
+            },
+
+            chunking: {
+                enabled: false,
+                concurrent: {
+                    enabled: false
+                },
+                mandatory: false,
+                paramNames: {
+                    partIndex: "qqpartindex",
+                    partByteOffset: "qqpartbyteoffset",
+                    chunkSize: "qqchunksize",
+                    totalFileSize: "qqtotalfilesize",
+                    totalParts: "qqtotalparts"
+                },
+                partSize: 2000000,
+                // only relevant for traditional endpoints, only required when concurrent.enabled === true
+                success: {
+                    endpoint: null
+                }
+            },
+
+            resume: {
+                enabled: false,
+                recordsExpireIn: 7, //days
+                paramNames: {
+                    resuming: "qqresume"
+                }
+            },
+
+            formatFileName: function(fileOrBlobName) {
+                return fileOrBlobName;
+            },
+
+            text: {
+                defaultResponseError: "Upload failure reason unknown",
+                sizeSymbols: ["kB", "MB", "GB", "TB", "PB", "EB"]
+            },
+
+            deleteFile: {
+                enabled: false,
+                method: "DELETE",
+                endpoint: "/server/upload",
+                customHeaders: {},
+                params: {}
+            },
+
+            cors: {
+                expected: false,
+                sendCredentials: false,
+                allowXdr: false
+            },
+
+            blobs: {
+                defaultName: "misc_data"
+            },
+
+            paste: {
+                targetElement: null,
+                defaultName: "pasted_image"
+            },
+
+            camera: {
+                ios: false,
+
+                // if ios is true: button is null means target the default button, otherwise target the button specified
+                button: null
+            },
+
+            // This refers to additional upload buttons to be handled by Fine Uploader.
+            // Each element is an object, containing `element` as the only required
+            // property.  The `element` must be a container that will ultimately
+            // contain an invisible `<input type="file">` created by Fine Uploader.
+            // Optional properties of each object include `multiple`, `validation`,
+            // and `folders`.
+            extraButtons: [],
+
+            // Depends on the session module.  Used to query the server for an initial file list
+            // during initialization and optionally after a `reset`.
+            session: {
+                endpoint: null,
+                params: {},
+                customHeaders: {},
+                refreshOnReset: true
+            },
+
+            // Send parameters associated with an existing form along with the files
+            form: {
+                // Element ID, HTMLElement, or null
+                element: "qq-form",
+
+                // Overrides the base `autoUpload`, unless `element` is null.
+                autoUpload: false,
+
+                // true = upload files on form submission (and squelch submit event)
+                interceptSubmit: true
+            },
+
+            // scale images client side, upload a new file for each scaled version
+            scaling: {
+                // send the original file as well
+                sendOriginal: true,
+
+                // fox orientation for scaled images
+                orient: true,
+
+                // If null, scaled image type will match reference image type.  This value will be referred to
+                // for any size record that does not specific a type.
+                defaultType: null,
+
+                defaultQuality: 80,
+
+                failureText: "Failed to scale",
+
+                includeExif: false,
+
+                // metadata about each requested scaled version
+                sizes: []
+            },
+
+            workarounds: {
+                iosEmptyVideos: true,
+                ios8SafariUploads: true,
+                ios8BrowserCrash: false
+            }
+        };
+
+        // Replace any default options with user defined ones
+        qq.extend(this._options, o, true);
+
+        this._buttons = [];
+        this._extraButtonSpecs = {};
+        this._buttonIdsForFileIds = [];
+
+        this._wrapCallbacks();
+        this._disposeSupport =  new qq.DisposeSupport();
+
+        this._storedIds = [];
+        this._autoRetries = [];
+        this._retryTimeouts = [];
+        this._preventRetries = [];
+        this._thumbnailUrls = [];
+
+        this._netUploadedOrQueued = 0;
+        this._netUploaded = 0;
+        this._uploadData = this._createUploadDataTracker();
+
+        this._initFormSupportAndParams();
+
+        this._customHeadersStore = this._createStore(this._options.request.customHeaders);
+        this._deleteFileCustomHeadersStore = this._createStore(this._options.deleteFile.customHeaders);
+
+        this._deleteFileParamsStore = this._createStore(this._options.deleteFile.params);
+
+        this._endpointStore = this._createStore(this._options.request.endpoint);
+        this._deleteFileEndpointStore = this._createStore(this._options.deleteFile.endpoint);
+
+        this._handler = this._createUploadHandler();
+
+        this._deleteHandler = qq.DeleteFileAjaxRequester && this._createDeleteHandler();
+
+        if (this._options.button) {
+            this._defaultButtonId = this._createUploadButton({element: this._options.button}).getButtonId();
+        }
+
+        this._generateExtraButtonSpecs();
+
+        this._handleCameraAccess();
+
+        if (this._options.paste.targetElement) {
+            if (qq.PasteSupport) {
+                this._pasteHandler = this._createPasteHandler();
+            }
+            else {
+                this.log("Paste support module not found", "error");
+            }
+        }
+
+        this._preventLeaveInProgress();
+
+        this._imageGenerator = qq.ImageGenerator && new qq.ImageGenerator(qq.bind(this.log, this));
+        this._refreshSessionData();
+
+        this._succeededSinceLastAllComplete = [];
+        this._failedSinceLastAllComplete = [];
+
+        this._scaler = (qq.Scaler && new qq.Scaler(this._options.scaling, qq.bind(this.log, this))) || {};
+        if (this._scaler.enabled) {
+            this._customNewFileHandler = qq.bind(this._scaler.handleNewFile, this._scaler);
+        }
+
+        if (qq.TotalProgress && qq.supportedFeatures.progressBar) {
+            this._totalProgress = new qq.TotalProgress(
+                qq.bind(this._onTotalProgress, this),
+
+                function(id) {
+                    var entry = self._uploadData.retrieve({id: id});
+                    return (entry && entry.size) || 0;
+                }
+            );
+        }
+
+        this._currentItemLimit = this._options.validation.itemLimit;
+    };
+
+    // Define the private & public API methods.
+    qq.FineUploaderBasic.prototype = qq.basePublicApi;
+    qq.extend(qq.FineUploaderBasic.prototype, qq.basePrivateApi);
+}());
+
+/*globals qq, XDomainRequest*/
+/** Generic class for sending non-upload ajax requests and handling the associated responses **/
+qq.AjaxRequester = function(o) {
+    "use strict";
+
+    var log, shouldParamsBeInQueryString,
+        queue = [],
+        requestData = {},
+        options = {
+            acceptHeader: null,
+            validMethods: ["PATCH", "POST", "PUT"],
+            method: "POST",
+            contentType: "application/x-www-form-urlencoded",
+            maxConnections: 3,
+            customHeaders: {},
+            endpointStore: {},
+            paramsStore: {},
+            mandatedParams: {},
+            allowXRequestedWithAndCacheControl: true,
+            successfulResponseCodes: {
+                DELETE: [200, 202, 204],
+                PATCH: [200, 201, 202, 203, 204],
+                POST: [200, 201, 202, 203, 204],
+                PUT: [200, 201, 202, 203, 204],
+                GET: [200]
+            },
+            cors: {
+                expected: false,
+                sendCredentials: false
+            },
+            log: function(str, level) {},
+            onSend: function(id) {},
+            onComplete: function(id, xhrOrXdr, isError) {},
+            onProgress: null
+        };
+
+    qq.extend(options, o);
+    log = options.log;
+
+    if (qq.indexOf(options.validMethods, options.method) < 0) {
+        throw new Error("'" + options.method + "' is not a supported method for this type of request!");
+    }
+
+    // [Simple methods](http://www.w3.org/TR/cors/#simple-method)
+    // are defined by the W3C in the CORS spec as a list of methods that, in part,
+    // make a CORS request eligible to be exempt from preflighting.
+    function isSimpleMethod() {
+        return qq.indexOf(["GET", "POST", "HEAD"], options.method) >= 0;
+    }
+
+    // [Simple headers](http://www.w3.org/TR/cors/#simple-header)
+    // are defined by the W3C in the CORS spec as a list of headers that, in part,
+    // make a CORS request eligible to be exempt from preflighting.
+    function containsNonSimpleHeaders(headers) {
+        var containsNonSimple = false;
+
+        qq.each(containsNonSimple, function(idx, header) {
+            if (qq.indexOf(["Accept", "Accept-Language", "Content-Language", "Content-Type"], header) < 0) {
+                containsNonSimple = true;
+                return false;
+            }
+        });
+
+        return containsNonSimple;
+    }
+
+    function isXdr(xhr) {
+        //The `withCredentials` test is a commonly accepted way to determine if XHR supports CORS.
+        return options.cors.expected && xhr.withCredentials === undefined;
+    }
+
+    // Returns either a new `XMLHttpRequest` or `XDomainRequest` instance.
+    function getCorsAjaxTransport() {
+        var xhrOrXdr;
+
+        if (window.XMLHttpRequest || window.ActiveXObject) {
+            xhrOrXdr = qq.createXhrInstance();
+
+            if (xhrOrXdr.withCredentials === undefined) {
+                xhrOrXdr = new XDomainRequest();
+            }
+        }
+
+        return xhrOrXdr;
+    }
+
+    // Returns either a new XHR/XDR instance, or an existing one for the associated `File` or `Blob`.
+    function getXhrOrXdr(id, suppliedXhr) {
+        var xhrOrXdr = requestData[id].xhr;
+
+        if (!xhrOrXdr) {
+            if (suppliedXhr) {
+                xhrOrXdr = suppliedXhr;
+            }
+            else {
+                if (options.cors.expected) {
+                    xhrOrXdr = getCorsAjaxTransport();
+                }
+                else {
+                    xhrOrXdr = qq.createXhrInstance();
+                }
+            }
+
+            requestData[id].xhr = xhrOrXdr;
+        }
+
+        return xhrOrXdr;
+    }
+
+    // Removes element from queue, sends next request
+    function dequeue(id) {
+        var i = qq.indexOf(queue, id),
+            max = options.maxConnections,
+            nextId;
+
+        delete requestData[id];
+        queue.splice(i, 1);
+
+        if (queue.length >= max && i < max) {
+            nextId = queue[max - 1];
+            sendRequest(nextId);
+        }
+    }
+
+    function onComplete(id, xdrError) {
+        var xhr = getXhrOrXdr(id),
+            method = options.method,
+            isError = xdrError === true;
+
+        dequeue(id);
+
+        if (isError) {
+            log(method + " request for " + id + " has failed", "error");
+        }
+        else if (!isXdr(xhr) && !isResponseSuccessful(xhr.status)) {
+            isError = true;
+            log(method + " request for " + id + " has failed - response code " + xhr.status, "error");
+        }
+
+        options.onComplete(id, xhr, isError);
+    }
+
+    function getParams(id) {
+        var onDemandParams = requestData[id].additionalParams,
+            mandatedParams = options.mandatedParams,
+            params;
+
+        if (options.paramsStore.get) {
+            params = options.paramsStore.get(id);
+        }
+
+        if (onDemandParams) {
+            qq.each(onDemandParams, function(name, val) {
+                params = params || {};
+                params[name] = val;
+            });
+        }
+
+        if (mandatedParams) {
+            qq.each(mandatedParams, function(name, val) {
+                params = params || {};
+                params[name] = val;
+            });
+        }
+
+        return params;
+    }
+
+    function sendRequest(id, optXhr) {
+        var xhr = getXhrOrXdr(id, optXhr),
+            method = options.method,
+            params = getParams(id),
+            payload = requestData[id].payload,
+            url;
+
+        options.onSend(id);
+
+        url = createUrl(id, params);
+
+        // XDR and XHR status detection APIs differ a bit.
+        if (isXdr(xhr)) {
+            xhr.onload = getXdrLoadHandler(id);
+            xhr.onerror = getXdrErrorHandler(id);
+        }
+        else {
+            xhr.onreadystatechange = getXhrReadyStateChangeHandler(id);
+        }
+
+        registerForUploadProgress(id);
+
+        // The last parameter is assumed to be ignored if we are actually using `XDomainRequest`.
+        xhr.open(method, url, true);
+
+        // Instruct the transport to send cookies along with the CORS request,
+        // unless we are using `XDomainRequest`, which is not capable of this.
+        if (options.cors.expected && options.cors.sendCredentials && !isXdr(xhr)) {
+            xhr.withCredentials = true;
+        }
+
+        setHeaders(id);
+
+        log("Sending " + method + " request for " + id);
+
+        if (payload) {
+            xhr.send(payload);
+        }
+        else if (shouldParamsBeInQueryString || !params) {
+            xhr.send();
+        }
+        else if (params && options.contentType && options.contentType.toLowerCase().indexOf("application/x-www-form-urlencoded") >= 0) {
+            xhr.send(qq.obj2url(params, ""));
+        }
+        else if (params && options.contentType && options.contentType.toLowerCase().indexOf("application/json") >= 0) {
+            xhr.send(JSON.stringify(params));
+        }
+        else {
+            xhr.send(params);
+        }
+
+        return xhr;
+    }
+
+    function createUrl(id, params) {
+        var endpoint = options.endpointStore.get(id),
+            addToPath = requestData[id].addToPath;
+
+        /*jshint -W116,-W041 */
+        if (addToPath != undefined) {
+            endpoint += "/" + addToPath;
+        }
+
+        if (shouldParamsBeInQueryString && params) {
+            return qq.obj2url(params, endpoint);
+        }
+        else {
+            return endpoint;
+        }
+    }
+
+    // Invoked by the UA to indicate a number of possible states that describe
+    // a live `XMLHttpRequest` transport.
+    function getXhrReadyStateChangeHandler(id) {
+        return function() {
+            if (getXhrOrXdr(id).readyState === 4) {
+                onComplete(id);
+            }
+        };
+    }
+
+    function registerForUploadProgress(id) {
+        var onProgress = options.onProgress;
+
+        if (onProgress) {
+            getXhrOrXdr(id).upload.onprogress = function(e) {
+                if (e.lengthComputable) {
+                    onProgress(id, e.loaded, e.total);
+                }
+            };
+        }
+    }
+
+    // This will be called by IE to indicate **success** for an associated
+    // `XDomainRequest` transported request.
+    function getXdrLoadHandler(id) {
+        return function() {
+            onComplete(id);
+        };
+    }
+
+    // This will be called by IE to indicate **failure** for an associated
+    // `XDomainRequest` transported request.
+    function getXdrErrorHandler(id) {
+        return function() {
+            onComplete(id, true);
+        };
+    }
+
+    function setHeaders(id) {
+        var xhr = getXhrOrXdr(id),
+            customHeaders = options.customHeaders,
+            onDemandHeaders = requestData[id].additionalHeaders || {},
+            method = options.method,
+            allHeaders = {};
+
+        // If XDomainRequest is being used, we can't set headers, so just ignore this block.
+        if (!isXdr(xhr)) {
+            options.acceptHeader && xhr.setRequestHeader("Accept", options.acceptHeader);
+
+            // Only attempt to add X-Requested-With & Cache-Control if permitted
+            if (options.allowXRequestedWithAndCacheControl) {
+                // Do not add X-Requested-With & Cache-Control if this is a cross-origin request
+                // OR the cross-origin request contains a non-simple method or header.
+                // This is done to ensure a preflight is not triggered exclusively based on the
+                // addition of these 2 non-simple headers.
+                if (!options.cors.expected || (!isSimpleMethod() || containsNonSimpleHeaders(customHeaders))) {
+                    xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+                    xhr.setRequestHeader("Cache-Control", "no-cache");
+                }
+            }
+
+            if (options.contentType && (method === "POST" || method === "PUT")) {
+                xhr.setRequestHeader("Content-Type", options.contentType);
+            }
+
+            qq.extend(allHeaders, qq.isFunction(customHeaders) ? customHeaders(id) : customHeaders);
+            qq.extend(allHeaders, onDemandHeaders);
+
+            qq.each(allHeaders, function(name, val) {
+                xhr.setRequestHeader(name, val);
+            });
+        }
+    }
+
+    function isResponseSuccessful(responseCode) {
+        return qq.indexOf(options.successfulResponseCodes[options.method], responseCode) >= 0;
+    }
+
+    function prepareToSend(id, optXhr, addToPath, additionalParams, additionalHeaders, payload) {
+        requestData[id] = {
+            addToPath: addToPath,
+            additionalParams: additionalParams,
+            additionalHeaders: additionalHeaders,
+            payload: payload
+        };
+
+        var len = queue.push(id);
+
+        // if too many active connections, wait...
+        if (len <= options.maxConnections) {
+            return sendRequest(id, optXhr);
+        }
+    }
+
+    shouldParamsBeInQueryString = options.method === "GET" || options.method === "DELETE";
+
+    qq.extend(this, {
+        // Start the process of sending the request.  The ID refers to the file associated with the request.
+        initTransport: function(id) {
+            var path, params, headers, payload, cacheBuster;
+
+            return {
+                // Optionally specify the end of the endpoint path for the request.
+                withPath: function(appendToPath) {
+                    path = appendToPath;
+                    return this;
+                },
+
+                // Optionally specify additional parameters to send along with the request.
+                // These will be added to the query string for GET/DELETE requests or the payload
+                // for POST/PUT requests.  The Content-Type of the request will be used to determine
+                // how these parameters should be formatted as well.
+                withParams: function(additionalParams) {
+                    params = additionalParams;
+                    return this;
+                },
+
+                // Optionally specify additional headers to send along with the request.
+                withHeaders: function(additionalHeaders) {
+                    headers = additionalHeaders;
+                    return this;
+                },
+
+                // Optionally specify a payload/body for the request.
+                withPayload: function(thePayload) {
+                    payload = thePayload;
+                    return this;
+                },
+
+                // Appends a cache buster (timestamp) to the request URL as a query parameter (only if GET or DELETE)
+                withCacheBuster: function() {
+                    cacheBuster = true;
+                    return this;
+                },
+
+                // Send the constructed request.
+                send: function(optXhr) {
+                    if (cacheBuster && qq.indexOf(["GET", "DELETE"], options.method) >= 0) {
+                        params.qqtimestamp = new Date().getTime();
+                    }
+
+                    return prepareToSend(id, optXhr, path, params, headers, payload);
+                }
+            };
+        },
+
+        canceled: function(id) {
+            dequeue(id);
+        }
+    });
+};
+
+/* globals qq */
+/**
+ * Common upload handler functions.
+ *
+ * @constructor
+ */
+qq.UploadHandler = function(spec) {
+    "use strict";
+
+    var proxy = spec.proxy,
+        fileState = {},
+        onCancel = proxy.onCancel,
+        getName = proxy.getName;
+
+    qq.extend(this, {
+        add: function(id, fileItem) {
+            fileState[id] = fileItem;
+            fileState[id].temp = {};
+        },
+
+        cancel: function(id) {
+            var self = this,
+                cancelFinalizationEffort = new qq.Promise(),
+                onCancelRetVal = onCancel(id, getName(id), cancelFinalizationEffort);
+
+            onCancelRetVal.then(function() {
+                if (self.isValid(id)) {
+                    fileState[id].canceled = true;
+                    self.expunge(id);
+                }
+                cancelFinalizationEffort.success();
+            });
+        },
+
+        expunge: function(id) {
+            delete fileState[id];
+        },
+
+        getThirdPartyFileId: function(id) {
+            return fileState[id].key;
+        },
+
+        isValid: function(id) {
+            return fileState[id] !== undefined;
+        },
+
+        reset: function() {
+            fileState = {};
+        },
+
+        _getFileState: function(id) {
+            return fileState[id];
+        },
+
+        _setThirdPartyFileId: function(id, thirdPartyFileId) {
+            fileState[id].key = thirdPartyFileId;
+        },
+
+        _wasCanceled: function(id) {
+            return !!fileState[id].canceled;
+        }
+    });
+};
+
+/*globals qq*/
+/**
+ * Base upload handler module.  Controls more specific handlers.
+ *
+ * @param o Options.  Passed along to the specific handler submodule as well.
+ * @param namespace [optional] Namespace for the specific handler.
+ */
+qq.UploadHandlerController = function(o, namespace) {
+    "use strict";
+
+    var controller = this,
+        chunkingPossible = false,
+        concurrentChunkingPossible = false,
+        chunking, preventRetryResponse, log, handler,
+
+    options = {
+        paramsStore: {},
+        maxConnections: 3, // maximum number of concurrent uploads
+        chunking: {
+            enabled: false,
+            multiple: {
+                enabled: false
+            }
+        },
+        log: function(str, level) {},
+        onProgress: function(id, fileName, loaded, total) {},
+        onComplete: function(id, fileName, response, xhr) {},
+        onCancel: function(id, fileName) {},
+        onUploadPrep: function(id) {}, // Called if non-trivial operations will be performed before onUpload
+        onUpload: function(id, fileName) {},
+        onUploadChunk: function(id, fileName, chunkData) {},
+        onUploadChunkSuccess: function(id, chunkData, response, xhr) {},
+        onAutoRetry: function(id, fileName, response, xhr) {},
+        onResume: function(id, fileName, chunkData) {},
+        onUuidChanged: function(id, newUuid) {},
+        getName: function(id) {},
+        setSize: function(id, newSize) {},
+        isQueued: function(id) {},
+        getIdsInProxyGroup: function(id) {},
+        getIdsInBatch: function(id) {}
+    },
+
+    chunked = {
+        // Called when each chunk has uploaded successfully
+        done: function(id, chunkIdx, response, xhr) {
+            var chunkData = handler._getChunkData(id, chunkIdx);
+
+            handler._getFileState(id).attemptingResume = false;
+
+            delete handler._getFileState(id).temp.chunkProgress[chunkIdx];
+            handler._getFileState(id).loaded += chunkData.size;
+
+            options.onUploadChunkSuccess(id, handler._getChunkDataForCallback(chunkData), response, xhr);
+        },
+
+        // Called when all chunks have been successfully uploaded and we want to ask the handler to perform any
+        // logic associated with closing out the file, such as combining the chunks.
+        finalize: function(id) {
+            var size = options.getSize(id),
+                name = options.getName(id);
+
+            log("All chunks have been uploaded for " + id + " - finalizing....");
+            handler.finalizeChunks(id).then(
+                function(response, xhr) {
+                    log("Finalize successful for " + id);
+
+                    var normaizedResponse = upload.normalizeResponse(response, true);
+
+                    options.onProgress(id, name, size, size);
+                    handler._maybeDeletePersistedChunkData(id);
+                    upload.cleanup(id, normaizedResponse, xhr);
+                },
+                function(response, xhr) {
+                    var normaizedResponse = upload.normalizeResponse(response, false);
+
+                    log("Problem finalizing chunks for file ID " + id + " - " + normaizedResponse.error, "error");
+
+                    if (normaizedResponse.reset) {
+                        chunked.reset(id);
+                    }
+
+                    if (!options.onAutoRetry(id, name, normaizedResponse, xhr)) {
+                        upload.cleanup(id, normaizedResponse, xhr);
+                    }
+                }
+            );
+        },
+
+        hasMoreParts: function(id) {
+            return !!handler._getFileState(id).chunking.remaining.length;
+        },
+
+        nextPart: function(id) {
+            var nextIdx = handler._getFileState(id).chunking.remaining.shift();
+
+            if (nextIdx >= handler._getTotalChunks(id)) {
+                nextIdx = null;
+            }
+
+            return nextIdx;
+        },
+
+        reset: function(id) {
+            log("Server or callback has ordered chunking effort to be restarted on next attempt for item ID " + id, "error");
+
+            handler._maybeDeletePersistedChunkData(id);
+            handler.reevaluateChunking(id);
+            handler._getFileState(id).loaded = 0;
+        },
+
+        sendNext: function(id) {
+            var size = options.getSize(id),
+                name = options.getName(id),
+                chunkIdx = chunked.nextPart(id),
+                chunkData = handler._getChunkData(id, chunkIdx),
+                resuming = handler._getFileState(id).attemptingResume,
+                inProgressChunks = handler._getFileState(id).chunking.inProgress || [];
+
+            if (handler._getFileState(id).loaded == null) {
+                handler._getFileState(id).loaded = 0;
+            }
+
+            // Don't follow-through with the resume attempt if the integrator returns false from onResume
+            if (resuming && options.onResume(id, name, chunkData) === false) {
+                chunked.reset(id);
+                chunkIdx = chunked.nextPart(id);
+                chunkData = handler._getChunkData(id, chunkIdx);
+                resuming = false;
+            }
+
+            // If all chunks have already uploaded successfully, we must be re-attempting the finalize step.
+            if (chunkIdx == null && inProgressChunks.length === 0) {
+                chunked.finalize(id);
+            }
+
+            // Send the next chunk
+            else {
+                log("Sending chunked upload request for item " + id + ": bytes " + (chunkData.start + 1) + "-" + chunkData.end + " of " + size);
+                options.onUploadChunk(id, name, handler._getChunkDataForCallback(chunkData));
+
+                inProgressChunks.push(chunkIdx);
+                handler._getFileState(id).chunking.inProgress = inProgressChunks;
+
+                if (concurrentChunkingPossible) {
+                    connectionManager.open(id, chunkIdx);
+                }
+
+                if (concurrentChunkingPossible && connectionManager.available() && handler._getFileState(id).chunking.remaining.length) {
+                    chunked.sendNext(id);
+                }
+
+                handler.uploadChunk(id, chunkIdx, resuming).then(
+                    // upload chunk success
+                    function success(response, xhr) {
+                        log("Chunked upload request succeeded for " + id + ", chunk " + chunkIdx);
+
+                        handler.clearCachedChunk(id, chunkIdx);
+
+                        var inProgressChunks = handler._getFileState(id).chunking.inProgress || [],
+                            responseToReport = upload.normalizeResponse(response, true),
+                            inProgressChunkIdx = qq.indexOf(inProgressChunks, chunkIdx);
+
+                        log(qq.format("Chunk {} for file {} uploaded successfully.", chunkIdx, id));
+
+                        chunked.done(id, chunkIdx, responseToReport, xhr);
+
+                        if (inProgressChunkIdx >= 0) {
+                            inProgressChunks.splice(inProgressChunkIdx, 1);
+                        }
+
+                        handler._maybePersistChunkedState(id);
+
+                        if (!chunked.hasMoreParts(id) && inProgressChunks.length === 0) {
+                            chunked.finalize(id);
+                        }
+                        else if (chunked.hasMoreParts(id)) {
+                            chunked.sendNext(id);
+                        }
+                    },
+
+                    // upload chunk failure
+                    function failure(response, xhr) {
+                        log("Chunked upload request failed for " + id + ", chunk " + chunkIdx);
+
+                        handler.clearCachedChunk(id, chunkIdx);
+
+                        var responseToReport = upload.normalizeResponse(response, false),
+                            inProgressIdx;
+
+                        if (responseToReport.reset) {
+                            chunked.reset(id);
+                        }
+                        else {
+                            inProgressIdx = qq.indexOf(handler._getFileState(id).chunking.inProgress, chunkIdx);
+                            if (inProgressIdx >= 0) {
+                                handler._getFileState(id).chunking.inProgress.splice(inProgressIdx, 1);
+                                handler._getFileState(id).chunking.remaining.unshift(chunkIdx);
+                            }
+                        }
+
+                        // We may have aborted all other in-progress chunks for this file due to a failure.
+                        // If so, ignore the failures associated with those aborts.
+                        if (!handler._getFileState(id).temp.ignoreFailure) {
+                            // If this chunk has failed, we want to ignore all other failures of currently in-progress
+                            // chunks since they will be explicitly aborted
+                            if (concurrentChunkingPossible) {
+                                handler._getFileState(id).temp.ignoreFailure = true;
+
+                                qq.each(handler._getXhrs(id), function(ckid, ckXhr) {
+                                    ckXhr.abort();
+                                });
+
+                                // We must indicate that all aborted chunks are no longer in progress
+                                handler.moveInProgressToRemaining(id);
+
+                                // Free up any connections used by these chunks, but don't allow any
+                                // other files to take up the connections (until we have exhausted all auto-retries)
+                                connectionManager.free(id, true);
+                            }
+
+                            if (!options.onAutoRetry(id, name, responseToReport, xhr)) {
+                                // If one chunk fails, abort all of the others to avoid odd race conditions that occur
+                                // if a chunk succeeds immediately after one fails before we have determined if the upload
+                                // is a failure or not.
+                                upload.cleanup(id, responseToReport, xhr);
+                            }
+                        }
+                    }
+                )
+                    .done(function() {
+                        handler.clearXhr(id, chunkIdx);
+                    }) ;
+            }
+        }
+    },
+
+    connectionManager = {
+        _open: [],
+        _openChunks: {},
+        _waiting: [],
+
+        available: function() {
+            var max = options.maxConnections,
+                openChunkEntriesCount = 0,
+                openChunksCount = 0;
+
+            qq.each(connectionManager._openChunks, function(fileId, openChunkIndexes) {
+                openChunkEntriesCount++;
+                openChunksCount += openChunkIndexes.length;
+            });
+
+            return max - (connectionManager._open.length - openChunkEntriesCount + openChunksCount);
+        },
+
+        /**
+         * Removes element from queue, starts upload of next
+         */
+        free: function(id, dontAllowNext) {
+            var allowNext = !dontAllowNext,
+                waitingIndex = qq.indexOf(connectionManager._waiting, id),
+                connectionsIndex = qq.indexOf(connectionManager._open, id),
+                nextId;
+
+            delete connectionManager._openChunks[id];
+
+            if (upload.getProxyOrBlob(id) instanceof qq.BlobProxy) {
+                log("Generated blob upload has ended for " + id + ", disposing generated blob.");
+                delete handler._getFileState(id).file;
+            }
+
+            // If this file was not consuming a connection, it was just waiting, so remove it from the waiting array
+            if (waitingIndex >= 0) {
+                connectionManager._waiting.splice(waitingIndex, 1);
+            }
+            // If this file was consuming a connection, allow the next file to be uploaded
+            else if (allowNext && connectionsIndex >= 0) {
+                connectionManager._open.splice(connectionsIndex, 1);
+
+                nextId = connectionManager._waiting.shift();
+                if (nextId >= 0) {
+                    connectionManager._open.push(nextId);
+                    upload.start(nextId);
+                }
+            }
+        },
+
+        getWaitingOrConnected: function() {
+            var waitingOrConnected = [];
+
+            // Chunked files may have multiple connections open per chunk (if concurrent chunking is enabled)
+            // We need to grab the file ID of any file that has at least one chunk consuming a connection.
+            qq.each(connectionManager._openChunks, function(fileId, chunks) {
+                if (chunks && chunks.length) {
+                    waitingOrConnected.push(parseInt(fileId));
+                }
+            });
+
+            // For non-chunked files, only one connection will be consumed per file.
+            // This is where we aggregate those file IDs.
+            qq.each(connectionManager._open, function(idx, fileId) {
+                if (!connectionManager._openChunks[fileId]) {
+                    waitingOrConnected.push(parseInt(fileId));
+                }
+            });
+
+            // There may be files waiting for a connection.
+            waitingOrConnected = waitingOrConnected.concat(connectionManager._waiting);
+
+            return waitingOrConnected;
+        },
+
+        isUsingConnection: function(id) {
+            return qq.indexOf(connectionManager._open, id) >= 0;
+        },
+
+        open: function(id, chunkIdx) {
+            if (chunkIdx == null) {
+                connectionManager._waiting.push(id);
+            }
+
+            if (connectionManager.available()) {
+                if (chunkIdx == null) {
+                    connectionManager._waiting.pop();
+                    connectionManager._open.push(id);
+                }
+                else {
+                    (function() {
+                        var openChunksEntry = connectionManager._openChunks[id] || [];
+                        openChunksEntry.push(chunkIdx);
+                        connectionManager._openChunks[id] = openChunksEntry;
+                    }());
+                }
+
+                return true;
+            }
+
+            return false;
+        },
+
+        reset: function() {
+            connectionManager._waiting = [];
+            connectionManager._open = [];
+        }
+    },
+
+    simple = {
+        send: function(id, name) {
+            handler._getFileState(id).loaded = 0;
+
+            log("Sending simple upload request for " + id);
+            handler.uploadFile(id).then(
+                function(response, optXhr) {
+                    log("Simple upload request succeeded for " + id);
+
+                    var responseToReport = upload.normalizeResponse(response, true),
+                        size = options.getSize(id);
+
+                    options.onProgress(id, name, size, size);
+                    upload.maybeNewUuid(id, responseToReport);
+                    upload.cleanup(id, responseToReport, optXhr);
+                },
+
+                function(response, optXhr) {
+                    log("Simple upload request failed for " + id);
+
+                    var responseToReport = upload.normalizeResponse(response, false);
+
+                    if (!options.onAutoRetry(id, name, responseToReport, optXhr)) {
+                        upload.cleanup(id, responseToReport, optXhr);
+                    }
+                }
+            );
+        }
+    },
+
+    upload = {
+        cancel: function(id) {
+            log("Cancelling " + id);
+            options.paramsStore.remove(id);
+            connectionManager.free(id);
+        },
+
+        cleanup: function(id, response, optXhr) {
+            var name = options.getName(id);
+
+            options.onComplete(id, name, response, optXhr);
+
+            if (handler._getFileState(id)) {
+                handler._clearXhrs && handler._clearXhrs(id);
+            }
+
+            connectionManager.free(id);
+        },
+
+        // Returns a qq.BlobProxy, or an actual File/Blob if no proxy is involved, or undefined
+        // if none of these are available for the ID
+        getProxyOrBlob: function(id) {
+            return (handler.getProxy && handler.getProxy(id)) ||
+                (handler.getFile && handler.getFile(id));
+        },
+
+        initHandler: function() {
+            var handlerType = namespace ? qq[namespace] : qq.traditional,
+                handlerModuleSubtype = qq.supportedFeatures.ajaxUploading ? "Xhr" : "Form";
+
+            handler = new handlerType[handlerModuleSubtype + "UploadHandler"](
+                options,
+                {
+                    getDataByUuid: options.getDataByUuid,
+                    getName: options.getName,
+                    getSize: options.getSize,
+                    getUuid: options.getUuid,
+                    log: log,
+                    onCancel: options.onCancel,
+                    onProgress: options.onProgress,
+                    onUuidChanged: options.onUuidChanged
+                }
+            );
+
+            if (handler._removeExpiredChunkingRecords) {
+                handler._removeExpiredChunkingRecords();
+            }
+        },
+
+        isDeferredEligibleForUpload: function(id) {
+            return options.isQueued(id);
+        },
+
+        // For Blobs that are part of a group of generated images, along with a reference image,
+        // this will ensure the blobs in the group are uploaded in the order they were triggered,
+        // even if some async processing must be completed on one or more Blobs first.
+        maybeDefer: function(id, blob) {
+            // If we don't have a file/blob yet & no file/blob exists for this item, request it,
+            // and then submit the upload to the specific handler once the blob is available.
+            // ASSUMPTION: This condition will only ever be true if XHR uploading is supported.
+            if (blob && !handler.getFile(id) && blob instanceof qq.BlobProxy) {
+
+                // Blob creation may take some time, so the caller may want to update the
+                // UI to indicate that an operation is in progress, even before the actual
+                // upload begins and an onUpload callback is invoked.
+                options.onUploadPrep(id);
+
+                log("Attempting to generate a blob on-demand for " + id);
+                blob.create().then(function(generatedBlob) {
+                    log("Generated an on-demand blob for " + id);
+
+                    // Update record associated with this file by providing the generated Blob
+                    handler.updateBlob(id, generatedBlob);
+
+                    // Propagate the size for this generated Blob
+                    options.setSize(id, generatedBlob.size);
+
+                    // Order handler to recalculate chunking possibility, if applicable
+                    handler.reevaluateChunking(id);
+
+                    upload.maybeSendDeferredFiles(id);
+                },
+
+                // Blob could not be generated.  Fail the upload & attempt to prevent retries.  Also bubble error message.
+                function(errorMessage) {
+                    var errorResponse = {};
+
+                    if (errorMessage) {
+                        errorResponse.error = errorMessage;
+                    }
+
+                    log(qq.format("Failed to generate blob for ID {}.  Error message: {}.", id, errorMessage), "error");
+
+                    options.onComplete(id, options.getName(id), qq.extend(errorResponse, preventRetryResponse), null);
+                    upload.maybeSendDeferredFiles(id);
+                    connectionManager.free(id);
+                });
+            }
+            else {
+                return upload.maybeSendDeferredFiles(id);
+            }
+
+            return false;
+        },
+
+        // Upload any grouped blobs, in the proper order, that are ready to be uploaded
+        maybeSendDeferredFiles: function(id) {
+            var idsInGroup = options.getIdsInProxyGroup(id),
+                uploadedThisId = false;
+
+            if (idsInGroup && idsInGroup.length) {
+                log("Maybe ready to upload proxy group file " + id);
+
+                qq.each(idsInGroup, function(idx, idInGroup) {
+                    if (upload.isDeferredEligibleForUpload(idInGroup) && !!handler.getFile(idInGroup)) {
+                        uploadedThisId = idInGroup === id;
+                        upload.now(idInGroup);
+                    }
+                    else if (upload.isDeferredEligibleForUpload(idInGroup)) {
+                        return false;
+                    }
+                });
+            }
+            else {
+                uploadedThisId = true;
+                upload.now(id);
+            }
+
+            return uploadedThisId;
+        },
+
+        maybeNewUuid: function(id, response) {
+            if (response.newUuid !== undefined) {
+                options.onUuidChanged(id, response.newUuid);
+            }
+        },
+
+        // The response coming from handler implementations may be in various formats.
+        // Instead of hoping a promise nested 5 levels deep will always return an object
+        // as its first param, let's just normalize the response here.
+        normalizeResponse: function(originalResponse, successful) {
+            var response = originalResponse;
+
+            // The passed "response" param may not be a response at all.
+            // It could be a string, detailing the error, for example.
+            if (!qq.isObject(originalResponse)) {
+                response = {};
+
+                if (qq.isString(originalResponse) && !successful) {
+                    response.error = originalResponse;
+                }
+            }
+
+            response.success = successful;
+
+            return response;
+        },
+
+        now: function(id) {
+            var name = options.getName(id);
+
+            if (!controller.isValid(id)) {
+                throw new qq.Error(id + " is not a valid file ID to upload!");
+            }
+
+            options.onUpload(id, name);
+
+            if (chunkingPossible && handler._shouldChunkThisFile(id)) {
+                chunked.sendNext(id);
+            }
+            else {
+                simple.send(id, name);
+            }
+        },
+
+        start: function(id) {
+            var blobToUpload = upload.getProxyOrBlob(id);
+
+            if (blobToUpload) {
+                return upload.maybeDefer(id, blobToUpload);
+            }
+            else {
+                upload.now(id);
+                return true;
+            }
+        }
+    };
+
+    qq.extend(this, {
+        /**
+         * Adds file or file input to the queue
+         **/
+        add: function(id, file) {
+            handler.add.apply(this, arguments);
+        },
+
+        /**
+         * Sends the file identified by id
+         */
+        upload: function(id) {
+            if (connectionManager.open(id)) {
+                return upload.start(id);
+            }
+            return false;
+        },
+
+        retry: function(id) {
+            // On retry, if concurrent chunking has been enabled, we may have aborted all other in-progress chunks
+            // for a file when encountering a failed chunk upload.  We then signaled the controller to ignore
+            // all failures associated with these aborts.  We are now retrying, so we don't want to ignore
+            // any more failures at this point.
+            if (concurrentChunkingPossible) {
+                handler._getFileState(id).temp.ignoreFailure = false;
+            }
+
+            // If we are attempting to retry a file that is already consuming a connection, this is likely an auto-retry.
+            // Just go ahead and ask the handler to upload again.
+            if (connectionManager.isUsingConnection(id)) {
+                return upload.start(id);
+            }
+
+            // If we are attempting to retry a file that is not currently consuming a connection,
+            // this is likely a manual retry attempt.  We will need to ensure a connection is available
+            // before the retry commences.
+            else {
+                return controller.upload(id);
+            }
+        },
+
+        /**
+         * Cancels file upload by id
+         */
+        cancel: function(id) {
+            var cancelRetVal = handler.cancel(id);
+
+            if (qq.isGenericPromise(cancelRetVal)) {
+                cancelRetVal.then(function() {
+                    upload.cancel(id);
+                });
+            }
+            else if (cancelRetVal !== false) {
+                upload.cancel(id);
+            }
+        },
+
+        /**
+         * Cancels all queued or in-progress uploads
+         */
+        cancelAll: function() {
+            var waitingOrConnected = connectionManager.getWaitingOrConnected(),
+                i;
+
+            // ensure files are cancelled in reverse order which they were added
+            // to avoid a flash of time where a queued file begins to upload before it is canceled
+            if (waitingOrConnected.length) {
+                for (i = waitingOrConnected.length - 1; i >= 0; i--) {
+                    controller.cancel(waitingOrConnected[i]);
+                }
+            }
+
+            connectionManager.reset();
+        },
+
+        // Returns a File, Blob, or the Blob/File for the reference/parent file if the targeted blob is a proxy.
+        // Undefined if no file record is available.
+        getFile: function(id) {
+            if (handler.getProxy && handler.getProxy(id)) {
+                return handler.getProxy(id).referenceBlob;
+            }
+
+            return handler.getFile && handler.getFile(id);
+        },
+
+        // Returns true if the Blob associated with the ID is related to a proxy s
+        isProxied: function(id) {
+            return !!(handler.getProxy && handler.getProxy(id));
+        },
+
+        getInput: function(id) {
+            if (handler.getInput) {
+                return handler.getInput(id);
+            }
+        },
+
+        reset: function() {
+            log("Resetting upload handler");
+            controller.cancelAll();
+            connectionManager.reset();
+            handler.reset();
+        },
+
+        expunge: function(id) {
+            if (controller.isValid(id)) {
+                return handler.expunge(id);
+            }
+        },
+
+        /**
+         * Determine if the file exists.
+         */
+        isValid: function(id) {
+            return handler.isValid(id);
+        },
+
+        getResumableFilesData: function() {
+            if (handler.getResumableFilesData) {
+                return handler.getResumableFilesData();
+            }
+            return [];
+        },
+
+        /**
+         * This may or may not be implemented, depending on the handler.  For handlers where a third-party ID is
+         * available (such as the "key" for Amazon S3), this will return that value.  Otherwise, the return value
+         * will be undefined.
+         *
+         * @param id Internal file ID
+         * @returns {*} Some identifier used by a 3rd-party service involved in the upload process
+         */
+        getThirdPartyFileId: function(id) {
+            if (controller.isValid(id)) {
+                return handler.getThirdPartyFileId(id);
+            }
+        },
+
+        /**
+         * Attempts to pause the associated upload if the specific handler supports this and the file is "valid".
+         * @param id ID of the upload/file to pause
+         * @returns {boolean} true if the upload was paused
+         */
+        pause: function(id) {
+            if (controller.isResumable(id) && handler.pause && controller.isValid(id) && handler.pause(id)) {
+                connectionManager.free(id);
+                handler.moveInProgressToRemaining(id);
+                return true;
+            }
+            return false;
+        },
+
+        // True if the file is eligible for pause/resume.
+        isResumable: function(id) {
+            return !!handler.isResumable && handler.isResumable(id);
+        }
+    });
+
+    qq.extend(options, o);
+    log = options.log;
+    chunkingPossible = options.chunking.enabled && qq.supportedFeatures.chunking;
+    concurrentChunkingPossible = chunkingPossible && options.chunking.concurrent.enabled;
+
+    preventRetryResponse = (function() {
+        var response = {};
+
+        response[options.preventRetryParam] = true;
+
+        return response;
+    }());
+
+    upload.initHandler();
+};
+
+/* globals qq */
+/**
+ * Common APIs exposed to creators of upload via form/iframe handlers.  This is reused and possibly overridden
+ * in some cases by specific form upload handlers.
+ *
+ * @constructor
+ */
+qq.FormUploadHandler = function(spec) {
+    "use strict";
+
+    var options = spec.options,
+        handler = this,
+        proxy = spec.proxy,
+        formHandlerInstanceId = qq.getUniqueId(),
+        onloadCallbacks = {},
+        detachLoadEvents = {},
+        postMessageCallbackTimers = {},
+        isCors = options.isCors,
+        inputName = options.inputName,
+        getUuid = proxy.getUuid,
+        log = proxy.log,
+        corsMessageReceiver = new qq.WindowReceiveMessage({log: log});
+
+    /**
+     * Remove any trace of the file from the handler.
+     *
+     * @param id ID of the associated file
+     */
+    function expungeFile(id) {
+        delete detachLoadEvents[id];
+
+        // If we are dealing with CORS, we might still be waiting for a response from a loaded iframe.
+        // In that case, terminate the timer waiting for a message from the loaded iframe
+        // and stop listening for any more messages coming from this iframe.
+        if (isCors) {
+            clearTimeout(postMessageCallbackTimers[id]);
+            delete postMessageCallbackTimers[id];
+            corsMessageReceiver.stopReceivingMessages(id);
+        }
+
+        var iframe = document.getElementById(handler._getIframeName(id));
+        if (iframe) {
+            // To cancel request set src to something else.  We use src="javascript:false;"
+            // because it doesn't trigger ie6 prompt on https
+            /* jshint scripturl:true */
+            iframe.setAttribute("src", "javascript:false;");
+
+            qq(iframe).remove();
+        }
+    }
+
+    /**
+     * @param iframeName `document`-unique Name of the associated iframe
+     * @returns {*} ID of the associated file
+     */
+    function getFileIdForIframeName(iframeName) {
+        return iframeName.split("_")[0];
+    }
+
+    /**
+     * Generates an iframe to be used as a target for upload-related form submits.  This also adds the iframe
+     * to the current `document`.  Note that the iframe is hidden from view.
+     *
+     * @param name Name of the iframe.
+     * @returns {HTMLIFrameElement} The created iframe
+     */
+    function initIframeForUpload(name) {
+        var iframe = qq.toElement("<iframe src='javascript:false;' name='" + name + "' />");
+
+        iframe.setAttribute("id", name);
+
+        iframe.style.display = "none";
+        document.body.appendChild(iframe);
+
+        return iframe;
+    }
+
+    /**
+     * If we are in CORS mode, we must listen for messages (containing the server response) from the associated
+     * iframe, since we cannot directly parse the content of the iframe due to cross-origin restrictions.
+     *
+     * @param iframe Listen for messages on this iframe.
+     * @param callback Invoke this callback with the message from the iframe.
+     */
+    function registerPostMessageCallback(iframe, callback) {
+        var iframeName = iframe.id,
+            fileId = getFileIdForIframeName(iframeName),
+            uuid = getUuid(fileId);
+
+        onloadCallbacks[uuid] = callback;
+
+        // When the iframe has loaded (after the server responds to an upload request)
+        // declare the attempt a failure if we don't receive a valid message shortly after the response comes in.
+        detachLoadEvents[fileId] = qq(iframe).attach("load", function() {
+            if (handler.getInput(fileId)) {
+                log("Received iframe load event for CORS upload request (iframe name " + iframeName + ")");
+
+                postMessageCallbackTimers[iframeName] = setTimeout(function() {
+                    var errorMessage = "No valid message received from loaded iframe for iframe name " + iframeName;
+                    log(errorMessage, "error");
+                    callback({
+                        error: errorMessage
+                    });
+                }, 1000);
+            }
+        });
+
+        // Listen for messages coming from this iframe.  When a message has been received, cancel the timer
+        // that declares the upload a failure if a message is not received within a reasonable amount of time.
+        corsMessageReceiver.receiveMessage(iframeName, function(message) {
+            log("Received the following window message: '" + message + "'");
+            var fileId = getFileIdForIframeName(iframeName),
+                response = handler._parseJsonResponse(message),
+                uuid = response.uuid,
+                onloadCallback;
+
+            if (uuid && onloadCallbacks[uuid]) {
+                log("Handling response for iframe name " + iframeName);
+                clearTimeout(postMessageCallbackTimers[iframeName]);
+                delete postMessageCallbackTimers[iframeName];
+
+                handler._detachLoadEvent(iframeName);
+
+                onloadCallback = onloadCallbacks[uuid];
+
+                delete onloadCallbacks[uuid];
+                corsMessageReceiver.stopReceivingMessages(iframeName);
+                onloadCallback(response);
+            }
+            else if (!uuid) {
+                log("'" + message + "' does not contain a UUID - ignoring.");
+            }
+        });
+    }
+
+    qq.extend(this, new qq.UploadHandler(spec));
+
+    qq.override(this, function(super_) {
+        return {
+            /**
+             * Adds File or Blob to the queue
+             **/
+            add: function(id, fileInput) {
+                super_.add(id, {input: fileInput});
+
+                fileInput.setAttribute("name", inputName);
+
+                // remove file input from DOM
+                if (fileInput.parentNode) {
+                    qq(fileInput).remove();
+                }
+            },
+
+            expunge: function(id) {
+                expungeFile(id);
+                super_.expunge(id);
+            },
+
+            isValid: function(id) {
+                return super_.isValid(id) &&
+                    handler._getFileState(id).input !== undefined;
+            }
+        };
+    });
+
+    qq.extend(this, {
+        getInput: function(id) {
+            return handler._getFileState(id).input;
+        },
+
+        /**
+         * This function either delegates to a more specific message handler if CORS is involved,
+         * or simply registers a callback when the iframe has been loaded that invokes the passed callback
+         * after determining if the content of the iframe is accessible.
+         *
+         * @param iframe Associated iframe
+         * @param callback Callback to invoke after we have determined if the iframe content is accessible.
+         */
+        _attachLoadEvent: function(iframe, callback) {
+            /*jslint eqeq: true*/
+            var responseDescriptor;
+
+            if (isCors) {
+                registerPostMessageCallback(iframe, callback);
+            }
+            else {
+                detachLoadEvents[iframe.id] = qq(iframe).attach("load", function() {
+                    log("Received response for " + iframe.id);
+
+                    // when we remove iframe from dom
+                    // the request stops, but in IE load
+                    // event fires
+                    if (!iframe.parentNode) {
+                        return;
+                    }
+
+                    try {
+                        // fixing Opera 10.53
+                        if (iframe.contentDocument &&
+                            iframe.contentDocument.body &&
+                            iframe.contentDocument.body.innerHTML == "false") {
+                            // In Opera event is fired second time
+                            // when body.innerHTML changed from false
+                            // to server response approx. after 1 sec
+                            // when we upload file with iframe
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        //IE may throw an "access is denied" error when attempting to access contentDocument on the iframe in some cases
+                        log("Error when attempting to access iframe during handling of upload response (" + error.message + ")", "error");
+                        responseDescriptor = {success: false};
+                    }
+
+                    callback(responseDescriptor);
+                });
+            }
+        },
+
+        /**
+         * Creates an iframe with a specific document-unique name.
+         *
+         * @param id ID of the associated file
+         * @returns {HTMLIFrameElement}
+         */
+        _createIframe: function(id) {
+            var iframeName = handler._getIframeName(id);
+
+            return initIframeForUpload(iframeName);
+        },
+
+        /**
+         * Called when we are no longer interested in being notified when an iframe has loaded.
+         *
+         * @param id Associated file ID
+         */
+        _detachLoadEvent: function(id) {
+            if (detachLoadEvents[id] !== undefined) {
+                detachLoadEvents[id]();
+                delete detachLoadEvents[id];
+            }
+        },
+
+        /**
+         * @param fileId ID of the associated file
+         * @returns {string} The `document`-unique name of the iframe
+         */
+        _getIframeName: function(fileId) {
+            return fileId + "_" + formHandlerInstanceId;
+        },
+
+        /**
+         * Generates a form element and appends it to the `document`.  When the form is submitted, a specific iframe is targeted.
+         * The name of the iframe is passed in as a property of the spec parameter, and must be unique in the `document`.  Note
+         * that the form is hidden from view.
+         *
+         * @param spec An object containing various properties to be used when constructing the form.  Required properties are
+         * currently: `method`, `endpoint`, `params`, `paramsInBody`, and `targetName`.
+         * @returns {HTMLFormElement} The created form
+         */
+        _initFormForUpload: function(spec) {
+            var method = spec.method,
+                endpoint = spec.endpoint,
+                params = spec.params,
+                paramsInBody = spec.paramsInBody,
+                targetName = spec.targetName,
+                form = qq.toElement("<form method='" + method + "' enctype='multipart/form-data'></form>"),
+                url = endpoint;
+
+            if (paramsInBody) {
+                qq.obj2Inputs(params, form);
+            }
+            else {
+                url = qq.obj2url(params, endpoint);
+            }
+
+            form.setAttribute("action", url);
+            form.setAttribute("target", targetName);
+            form.style.display = "none";
+            document.body.appendChild(form);
+
+            return form;
+        },
+
+        /**
+         * @param innerHtmlOrMessage JSON message
+         * @returns {*} The parsed response, or an empty object if the response could not be parsed
+         */
+        _parseJsonResponse: function(innerHtmlOrMessage) {
+            var response = {};
+
+            try {
+                response = qq.parseJson(innerHtmlOrMessage);
+            }
+            catch (error) {
+                log("Error when attempting to parse iframe upload response (" + error.message + ")", "error");
+            }
+
+            return response;
+        }
+    });
+};
+
+/* globals qq */
+/**
+ * Common API exposed to creators of XHR handlers.  This is reused and possibly overriding in some cases by specific
+ * XHR upload handlers.
+ *
+ * @constructor
+ */
+qq.XhrUploadHandler = function(spec) {
+    "use strict";
+
+    var handler = this,
+        namespace = spec.options.namespace,
+        proxy = spec.proxy,
+        chunking = spec.options.chunking,
+        resume = spec.options.resume,
+        chunkFiles = chunking && spec.options.chunking.enabled && qq.supportedFeatures.chunking,
+        resumeEnabled = resume && spec.options.resume.enabled && chunkFiles && qq.supportedFeatures.resume,
+        getName = proxy.getName,
+        getSize = proxy.getSize,
+        getUuid = proxy.getUuid,
+        getEndpoint = proxy.getEndpoint,
+        getDataByUuid = proxy.getDataByUuid,
+        onUuidChanged = proxy.onUuidChanged,
+        onProgress = proxy.onProgress,
+        log = proxy.log;
+
+    function abort(id) {
+        qq.each(handler._getXhrs(id), function(xhrId, xhr) {
+            var ajaxRequester = handler._getAjaxRequester(id, xhrId);
+
+            xhr.onreadystatechange = null;
+            xhr.upload.onprogress = null;
+            xhr.abort();
+            ajaxRequester && ajaxRequester.canceled && ajaxRequester.canceled(id);
+        });
+    }
+
+    qq.extend(this, new qq.UploadHandler(spec));
+
+    qq.override(this, function(super_) {
+        return {
+            /**
+             * Adds File or Blob to the queue
+             **/
+            add: function(id, blobOrProxy) {
+                if (qq.isFile(blobOrProxy) || qq.isBlob(blobOrProxy)) {
+                    super_.add(id, {file: blobOrProxy});
+                }
+                else if (blobOrProxy instanceof qq.BlobProxy) {
+                    super_.add(id, {proxy: blobOrProxy});
+                }
+                else {
+                    throw new Error("Passed obj is not a File, Blob, or proxy");
+                }
+
+                handler._initTempState(id);
+                resumeEnabled && handler._maybePrepareForResume(id);
+            },
+
+            expunge: function(id) {
+                abort(id);
+                handler._maybeDeletePersistedChunkData(id);
+                handler._clearXhrs(id);
+                super_.expunge(id);
+            }
+        };
+    });
+
+    qq.extend(this, {
+        // Clear the cached chunk `Blob` after we are done with it, just in case the `Blob` bytes are stored in memory.
+        clearCachedChunk: function(id, chunkIdx) {
+            delete handler._getFileState(id).temp.cachedChunks[chunkIdx];
+        },
+
+        clearXhr: function(id, chunkIdx) {
+            var tempState = handler._getFileState(id).temp;
+
+            if (tempState.xhrs) {
+                delete tempState.xhrs[chunkIdx];
+            }
+            if (tempState.ajaxRequesters) {
+                delete tempState.ajaxRequesters[chunkIdx];
+            }
+        },
+
+        // Called when all chunks have been successfully uploaded.  Expected promissory return type.
+        // This defines the default behavior if nothing further is required when all chunks have been uploaded.
+        finalizeChunks: function(id, responseParser) {
+            var lastChunkIdx = handler._getTotalChunks(id) - 1,
+                xhr = handler._getXhr(id, lastChunkIdx);
+
+            if (responseParser) {
+                return new qq.Promise().success(responseParser(xhr), xhr);
+            }
+
+            return new qq.Promise().success({}, xhr);
+        },
+
+        getFile: function(id) {
+            return handler.isValid(id) && handler._getFileState(id).file;
+        },
+
+        getProxy: function(id) {
+            return handler.isValid(id) && handler._getFileState(id).proxy;
+        },
+
+        /**
+         * @returns {Array} Array of objects containing properties useful to integrators
+         * when it is important to determine which files are potentially resumable.
+         */
+        getResumableFilesData: function() {
+            var resumableFilesData = [];
+            handler._iterateResumeRecords(function(key, uploadData) {
+                handler.moveInProgressToRemaining(null, uploadData.chunking.inProgress,  uploadData.chunking.remaining);
+
+                var data = {
+                    name: uploadData.name,
+                    remaining: uploadData.chunking.remaining,
+                    size: uploadData.size,
+                    uuid: uploadData.uuid
+                };
+
+                if (uploadData.key) {
+                    data.key = uploadData.key;
+                }
+
+                resumableFilesData.push(data);
+            });
+
+            return resumableFilesData;
+        },
+
+        isResumable: function(id) {
+            return !!chunking && handler.isValid(id) && !handler._getFileState(id).notResumable;
+        },
+
+        moveInProgressToRemaining: function(id, optInProgress, optRemaining) {
+            var inProgress = optInProgress || handler._getFileState(id).chunking.inProgress,
+                remaining = optRemaining || handler._getFileState(id).chunking.remaining;
+
+            if (inProgress) {
+                inProgress.reverse();
+                qq.each(inProgress, function(idx, chunkIdx) {
+                    remaining.unshift(chunkIdx);
+                });
+                inProgress.length = 0;
+            }
+        },
+
+        pause: function(id) {
+            if (handler.isValid(id)) {
+                log(qq.format("Aborting XHR upload for {} '{}' due to pause instruction.", id, getName(id)));
+                handler._getFileState(id).paused = true;
+                abort(id);
+                return true;
+            }
+        },
+
+        reevaluateChunking: function(id) {
+            if (chunking && handler.isValid(id)) {
+                var state = handler._getFileState(id),
+                    totalChunks,
+                    i;
+
+                delete state.chunking;
+
+                state.chunking = {};
+                totalChunks = handler._getTotalChunks(id);
+                if (totalChunks > 1 || chunking.mandatory) {
+                    state.chunking.enabled = true;
+                    state.chunking.parts = totalChunks;
+                    state.chunking.remaining = [];
+
+                    for (i = 0; i < totalChunks; i++) {
+                        state.chunking.remaining.push(i);
+                    }
+
+                    handler._initTempState(id);
+                }
+                else {
+                    state.chunking.enabled = false;
+                }
+            }
+        },
+
+        updateBlob: function(id, newBlob) {
+            if (handler.isValid(id)) {
+                handler._getFileState(id).file = newBlob;
+            }
+        },
+
+        _clearXhrs: function(id) {
+            var tempState = handler._getFileState(id).temp;
+
+            qq.each(tempState.ajaxRequesters, function(chunkId) {
+                delete tempState.ajaxRequesters[chunkId];
+            });
+
+            qq.each(tempState.xhrs, function(chunkId) {
+                delete tempState.xhrs[chunkId];
+            });
+        },
+
+        /**
+         * Creates an XHR instance for this file and stores it in the fileState.
+         *
+         * @param id File ID
+         * @param optChunkIdx The chunk index associated with this XHR, if applicable
+         * @returns {XMLHttpRequest}
+         */
+        _createXhr: function(id, optChunkIdx) {
+            return handler._registerXhr(id, optChunkIdx, qq.createXhrInstance());
+        },
+
+        _getAjaxRequester: function(id, optChunkIdx) {
+            var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;
+            return handler._getFileState(id).temp.ajaxRequesters[chunkIdx];
+        },
+
+        _getChunkData: function(id, chunkIndex) {
+            var chunkSize = chunking.partSize,
+                fileSize = getSize(id),
+                fileOrBlob = handler.getFile(id),
+                startBytes = chunkSize * chunkIndex,
+                endBytes = startBytes + chunkSize >= fileSize ? fileSize : startBytes + chunkSize,
+                totalChunks = handler._getTotalChunks(id),
+                cachedChunks = this._getFileState(id).temp.cachedChunks,
+
+                // To work around a Webkit GC bug, we must keep each chunk `Blob` in scope until we are done with it.
+                // See https://github.com/Widen/fine-uploader/issues/937#issuecomment-41418760
+                blob = cachedChunks[chunkIndex] || qq.sliceBlob(fileOrBlob, startBytes, endBytes);
+
+            cachedChunks[chunkIndex] = blob;
+
+            return {
+                part: chunkIndex,
+                start: startBytes,
+                end: endBytes,
+                count: totalChunks,
+                blob: blob,
+                size: endBytes - startBytes
+            };
+        },
+
+        _getChunkDataForCallback: function(chunkData) {
+            return {
+                partIndex: chunkData.part,
+                startByte: chunkData.start + 1,
+                endByte: chunkData.end,
+                totalParts: chunkData.count
+            };
+        },
+
+        /**
+         * @param id File ID
+         * @returns {string} Identifier for this item that may appear in the browser's local storage
+         */
+        _getLocalStorageId: function(id) {
+            var formatVersion = "5.0",
+                name = getName(id),
+                size = getSize(id),
+                chunkSize = chunking.partSize,
+                endpoint = getEndpoint(id);
+
+            return qq.format("qq{}resume{}-{}-{}-{}-{}", namespace, formatVersion, name, size, chunkSize, endpoint);
+        },
+
+        _getMimeType: function(id) {
+            return handler.getFile(id).type;
+        },
+
+        _getPersistableData: function(id) {
+            return handler._getFileState(id).chunking;
+        },
+
+        /**
+         * @param id ID of the associated file
+         * @returns {number} Number of parts this file can be divided into, or undefined if chunking is not supported in this UA
+         */
+        _getTotalChunks: function(id) {
+            if (chunking) {
+                var fileSize = getSize(id),
+                    chunkSize = chunking.partSize;
+
+                return Math.ceil(fileSize / chunkSize);
+            }
+        },
+
+        _getXhr: function(id, optChunkIdx) {
+            var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;
+            return handler._getFileState(id).temp.xhrs[chunkIdx];
+        },
+
+        _getXhrs: function(id) {
+            return handler._getFileState(id).temp.xhrs;
+        },
+
+        // Iterates through all XHR handler-created resume records (in local storage),
+        // invoking the passed callback and passing in the key and value of each local storage record.
+        _iterateResumeRecords: function(callback) {
+            if (resumeEnabled) {
+                qq.each(localStorage, function(key, item) {
+                    if (key.indexOf(qq.format("qq{}resume-", namespace)) === 0) {
+                        var uploadData = JSON.parse(item);
+                        callback(key, uploadData);
+                    }
+                });
+            }
+        },
+
+        _initTempState: function(id) {
+            handler._getFileState(id).temp = {
+                ajaxRequesters: {},
+                chunkProgress: {},
+                xhrs: {},
+                cachedChunks: {}
+            };
+        },
+
+        _markNotResumable: function(id) {
+            handler._getFileState(id).notResumable = true;
+        },
+
+        // Removes a chunked upload record from local storage, if possible.
+        // Returns true if the item was removed, false otherwise.
+        _maybeDeletePersistedChunkData: function(id) {
+            var localStorageId;
+
+            if (resumeEnabled && handler.isResumable(id)) {
+                localStorageId = handler._getLocalStorageId(id);
+
+                if (localStorageId && localStorage.getItem(localStorageId)) {
+                    localStorage.removeItem(localStorageId);
+                    return true;
+                }
+            }
+
+            return false;
+        },
+
+        // If this is a resumable upload, grab the relevant data from storage and items in memory that track this upload
+        // so we can pick up from where we left off.
+        _maybePrepareForResume: function(id) {
+            var state = handler._getFileState(id),
+                localStorageId, persistedData;
+
+            // Resume is enabled and possible and this is the first time we've tried to upload this file in this session,
+            // so prepare for a resume attempt.
+            if (resumeEnabled && state.key === undefined) {
+                localStorageId = handler._getLocalStorageId(id);
+                persistedData = localStorage.getItem(localStorageId);
+
+                // If we found this item in local storage, maybe we should resume it.
+                if (persistedData) {
+                    persistedData = JSON.parse(persistedData);
+
+                    // If we found a resume record but we have already handled this file in this session,
+                    // don't try to resume it & ensure we don't persist future check data
+                    if (getDataByUuid(persistedData.uuid)) {
+                        handler._markNotResumable(id);
+                    }
+                    else {
+                        log(qq.format("Identified file with ID {} and name of {} as resumable.", id, getName(id)));
+
+                        onUuidChanged(id, persistedData.uuid);
+
+                        state.key = persistedData.key;
+                        state.chunking = persistedData.chunking;
+                        state.loaded = persistedData.loaded;
+                        state.attemptingResume = true;
+
+                        handler.moveInProgressToRemaining(id);
+                    }
+                }
+            }
+        },
+
+        // Persist any data needed to resume this upload in a new session.
+        _maybePersistChunkedState: function(id) {
+            var state = handler._getFileState(id),
+                localStorageId, persistedData;
+
+            // If local storage isn't supported by the browser, or if resume isn't enabled or possible, give up
+            if (resumeEnabled && handler.isResumable(id)) {
+                localStorageId = handler._getLocalStorageId(id);
+
+                persistedData = {
+                    name: getName(id),
+                    size: getSize(id),
+                    uuid: getUuid(id),
+                    key: state.key,
+                    chunking: state.chunking,
+                    loaded: state.loaded,
+                    lastUpdated: Date.now()
+                };
+
+                try {
+                    localStorage.setItem(localStorageId, JSON.stringify(persistedData));
+                }
+                catch (error) {
+                    log(qq.format("Unable to save resume data for '{}' due to error: '{}'.", id, error.toString()), "warn");
+                }
+            }
+        },
+
+        _registerProgressHandler: function(id, chunkIdx, chunkSize) {
+            var xhr = handler._getXhr(id, chunkIdx),
+                name = getName(id),
+                progressCalculator = {
+                    simple: function(loaded, total) {
+                        var fileSize = getSize(id);
+
+                        if (loaded === total) {
+                            onProgress(id, name, fileSize, fileSize);
+                        }
+                        else {
+                            onProgress(id, name, (loaded >= fileSize ? fileSize - 1 : loaded), fileSize);
+                        }
+                    },
+
+                    chunked: function(loaded, total) {
+                        var chunkProgress = handler._getFileState(id).temp.chunkProgress,
+                            totalSuccessfullyLoadedForFile = handler._getFileState(id).loaded,
+                            loadedForRequest = loaded,
+                            totalForRequest = total,
+                            totalFileSize = getSize(id),
+                            estActualChunkLoaded = loadedForRequest - (totalForRequest - chunkSize),
+                            totalLoadedForFile = totalSuccessfullyLoadedForFile;
+
+                        chunkProgress[chunkIdx] = estActualChunkLoaded;
+
+                        qq.each(chunkProgress, function(chunkIdx, chunkLoaded) {
+                            totalLoadedForFile += chunkLoaded;
+                        });
+
+                        onProgress(id, name, totalLoadedForFile, totalFileSize);
+                    }
+                };
+
+            xhr.upload.onprogress = function(e) {
+                if (e.lengthComputable) {
+                    /* jshint eqnull: true */
+                    var type = chunkSize == null ? "simple" : "chunked";
+                    progressCalculator[type](e.loaded, e.total);
+                }
+            };
+        },
+
+        /**
+         * Registers an XHR transport instance created elsewhere.
+         *
+         * @param id ID of the associated file
+         * @param optChunkIdx The chunk index associated with this XHR, if applicable
+         * @param xhr XMLHttpRequest object instance
+         * @param optAjaxRequester `qq.AjaxRequester` associated with this request, if applicable.
+         * @returns {XMLHttpRequest}
+         */
+        _registerXhr: function(id, optChunkIdx, xhr, optAjaxRequester) {
+            var xhrsId = optChunkIdx == null ? -1 : optChunkIdx,
+                tempState = handler._getFileState(id).temp;
+
+            tempState.xhrs = tempState.xhrs || {};
+            tempState.ajaxRequesters = tempState.ajaxRequesters || {};
+
+            tempState.xhrs[xhrsId] = xhr;
+
+            if (optAjaxRequester) {
+                tempState.ajaxRequesters[xhrsId] = optAjaxRequester;
+            }
+
+            return xhr;
+        },
+
+        // Deletes any local storage records that are "expired".
+        _removeExpiredChunkingRecords: function() {
+            var expirationDays = resume.recordsExpireIn;
+
+            handler._iterateResumeRecords(function(key, uploadData) {
+                var expirationDate = new Date(uploadData.lastUpdated);
+
+                // transform updated date into expiration date
+                expirationDate.setDate(expirationDate.getDate() + expirationDays);
+
+                if (expirationDate.getTime() <= Date.now()) {
+                    log("Removing expired resume record with key " + key);
+                    localStorage.removeItem(key);
+                }
+            });
+        },
+
+        /**
+         * Determine if the associated file should be chunked.
+         *
+         * @param id ID of the associated file
+         * @returns {*} true if chunking is enabled, possible, and the file can be split into more than 1 part
+         */
+        _shouldChunkThisFile: function(id) {
+            var state = handler._getFileState(id);
+
+            if (!state.chunking) {
+                handler.reevaluateChunking(id);
+            }
+
+            return state.chunking.enabled;
+        }
+    });
+};
+
+/*globals qq */
+/*jshint -W117 */
+qq.WindowReceiveMessage = function(o) {
+    "use strict";
+
+    var options = {
+            log: function(message, level) {}
+        },
+        callbackWrapperDetachers = {};
+
+    qq.extend(options, o);
+
+    qq.extend(this, {
+        receiveMessage: function(id, callback) {
+            var onMessageCallbackWrapper = function(event) {
+                    callback(event.data);
+                };
+
+            if (window.postMessage) {
+                callbackWrapperDetachers[id] = qq(window).attach("message", onMessageCallbackWrapper);
+            }
+            else {
+                log("iframe message passing not supported in this browser!", "error");
+            }
+        },
+
+        stopReceivingMessages: function(id) {
+            if (window.postMessage) {
+                var detacher = callbackWrapperDetachers[id];
+                if (detacher) {
+                    detacher();
+                }
+            }
+        }
+    });
+};
+
+/*globals qq */
+/**
+ * Defines the public API for FineUploader mode.
+ */
+(function() {
+    "use strict";
+
+    qq.uiPublicApi = {
+        clearStoredFiles: function() {
+            this._parent.prototype.clearStoredFiles.apply(this, arguments);
+            this._templating.clearFiles();
+        },
+
+        addExtraDropzone: function(element) {
+            this._dnd && this._dnd.setupExtraDropzone(element);
+        },
+
+        removeExtraDropzone: function(element) {
+            if (this._dnd) {
+                return this._dnd.removeDropzone(element);
+            }
+        },
+
+        getItemByFileId: function(id) {
+            return this._templating.getFileContainer(id);
+        },
+
+        reset: function() {
+            this._parent.prototype.reset.apply(this, arguments);
+            this._templating.reset();
+
+            if (!this._options.button && this._templating.getButton()) {
+                this._defaultButtonId = this._createUploadButton({element: this._templating.getButton()}).getButtonId();
+            }
+
+            if (this._dnd) {
+                this._dnd.dispose();
+                this._dnd = this._setupDragAndDrop();
+            }
+
+            this._totalFilesInBatch = 0;
+            this._filesInBatchAddedToUi = 0;
+
+            this._setupClickAndEditEventHandlers();
+        },
+
+        setName: function(id, newName) {
+            var formattedFilename = this._options.formatFileName(newName);
+
+            this._parent.prototype.setName.apply(this, arguments);
+            this._templating.updateFilename(id, formattedFilename);
+        },
+
+        pauseUpload: function(id) {
+            var paused = this._parent.prototype.pauseUpload.apply(this, arguments);
+
+            paused && this._templating.uploadPaused(id);
+            return paused;
+        },
+
+        continueUpload: function(id) {
+            var continued = this._parent.prototype.continueUpload.apply(this, arguments);
+
+            continued && this._templating.uploadContinued(id);
+            return continued;
+        },
+
+        getId: function(fileContainerOrChildEl) {
+            return this._templating.getFileId(fileContainerOrChildEl);
+        },
+
+        getDropTarget: function(fileId) {
+            var file = this.getFile(fileId);
+
+            return file.qqDropTarget;
+        }
+    };
+
+    /**
+     * Defines the private (internal) API for FineUploader mode.
+     */
+    qq.uiPrivateApi = {
+        _getButton: function(buttonId) {
+            var button = this._parent.prototype._getButton.apply(this, arguments);
+
+            if (!button) {
+                if (buttonId === this._defaultButtonId) {
+                    button = this._templating.getButton();
+                }
+            }
+
+            return button;
+        },
+
+        _removeFileItem: function(fileId) {
+            this._templating.removeFile(fileId);
+        },
+
+        _setupClickAndEditEventHandlers: function() {
+            this._fileButtonsClickHandler = qq.FileButtonsClickHandler && this._bindFileButtonsClickEvent();
+
+            // A better approach would be to check specifically for focusin event support by querying the DOM API,
+            // but the DOMFocusIn event is not exposed as a property, so we have to resort to UA string sniffing.
+            this._focusinEventSupported = !qq.firefox();
+
+            if (this._isEditFilenameEnabled())
+            {
+                this._filenameClickHandler = this._bindFilenameClickEvent();
+                this._filenameInputFocusInHandler = this._bindFilenameInputFocusInEvent();
+                this._filenameInputFocusHandler = this._bindFilenameInputFocusEvent();
+            }
+        },
+
+        _setupDragAndDrop: function() {
+            var self = this,
+                dropZoneElements = this._options.dragAndDrop.extraDropzones,
+                templating = this._templating,
+                defaultDropZone = templating.getDropZone();
+
+            defaultDropZone && dropZoneElements.push(defaultDropZone);
+
+            return new qq.DragAndDrop({
+                dropZoneElements: dropZoneElements,
+                allowMultipleItems: this._options.multiple,
+                classes: {
+                    dropActive: this._options.classes.dropActive
+                },
+                callbacks: {
+                    processingDroppedFiles: function() {
+                        templating.showDropProcessing();
+                    },
+                    processingDroppedFilesComplete: function(files, targetEl) {
+                        templating.hideDropProcessing();
+
+                        qq.each(files, function(idx, file) {
+                            file.qqDropTarget = targetEl;
+                        });
+
+                        if (files.length) {
+                            self.addFiles(files, null, null);
+                        }
+                    },
+                    dropError: function(code, errorData) {
+                        self._itemError(code, errorData);
+                    },
+                    dropLog: function(message, level) {
+                        self.log(message, level);
+                    }
+                }
+            });
+        },
+
+        _bindFileButtonsClickEvent: function() {
+            var self = this;
+
+            return new qq.FileButtonsClickHandler({
+                templating: this._templating,
+
+                log: function(message, lvl) {
+                    self.log(message, lvl);
+                },
+
+                onDeleteFile: function(fileId) {
+                    self.deleteFile(fileId);
+                },
+
+                onCancel: function(fileId) {
+                    self.cancel(fileId);
+                },
+
+                onRetry: function(fileId) {
+                    qq(self._templating.getFileContainer(fileId)).removeClass(self._classes.retryable);
+                    self._templating.hideRetry(fileId);
+                    self.retry(fileId);
+                },
+
+                onPause: function(fileId) {
+                    self.pauseUpload(fileId);
+                },
+
+                onContinue: function(fileId) {
+                    self.continueUpload(fileId);
+                },
+
+                onGetName: function(fileId) {
+                    return self.getName(fileId);
+                }
+            });
+        },
+
+        _isEditFilenameEnabled: function() {
+            /*jshint -W014 */
+            return this._templating.isEditFilenamePossible()
+                && !this._options.autoUpload
+                && qq.FilenameClickHandler
+                && qq.FilenameInputFocusHandler
+                && qq.FilenameInputFocusHandler;
+        },
+
+        _filenameEditHandler: function() {
+            var self = this,
+                templating = this._templating;
+
+            return {
+                templating: templating,
+                log: function(message, lvl) {
+                    self.log(message, lvl);
+                },
+                onGetUploadStatus: function(fileId) {
+                    return self.getUploads({id: fileId}).status;
+                },
+                onGetName: function(fileId) {
+                    return self.getName(fileId);
+                },
+                onSetName: function(id, newName) {
+                    self.setName(id, newName);
+                },
+                onEditingStatusChange: function(id, isEditing) {
+                    var qqInput = qq(templating.getEditInput(id)),
+                        qqFileContainer = qq(templating.getFileContainer(id));
+
+                    if (isEditing) {
+                        qqInput.addClass("qq-editing");
+                        templating.hideFilename(id);
+                        templating.hideEditIcon(id);
+                    }
+                    else {
+                        qqInput.removeClass("qq-editing");
+                        templating.showFilename(id);
+                        templating.showEditIcon(id);
+                    }
+
+                    // Force IE8 and older to repaint
+                    qqFileContainer.addClass("qq-temp").removeClass("qq-temp");
+                }
+            };
+        },
+
+        _onUploadStatusChange: function(id, oldStatus, newStatus) {
+            this._parent.prototype._onUploadStatusChange.apply(this, arguments);
+
+            if (this._isEditFilenameEnabled()) {
+                // Status for a file exists before it has been added to the DOM, so we must be careful here.
+                if (this._templating.getFileContainer(id) && newStatus !== qq.status.SUBMITTED) {
+                    this._templating.markFilenameEditable(id);
+                    this._templating.hideEditIcon(id);
+                }
+            }
+
+            if (newStatus === qq.status.UPLOAD_RETRYING) {
+                this._templating.setStatusText(id);
+                qq(this._templating.getFileContainer(id)).removeClass(this._classes.retrying);
+            }
+            else if (newStatus === qq.status.UPLOAD_FAILED) {
+                this._templating.hidePause(id);
+            }
+        },
+
+        _bindFilenameInputFocusInEvent: function() {
+            var spec = qq.extend({}, this._filenameEditHandler());
+
+            return new qq.FilenameInputFocusInHandler(spec);
+        },
+
+        _bindFilenameInputFocusEvent: function() {
+            var spec = qq.extend({}, this._filenameEditHandler());
+
+            return new qq.FilenameInputFocusHandler(spec);
+        },
+
+        _bindFilenameClickEvent: function() {
+            var spec = qq.extend({}, this._filenameEditHandler());
+
+            return new qq.FilenameClickHandler(spec);
+        },
+
+        _storeForLater: function(id) {
+            this._parent.prototype._storeForLater.apply(this, arguments);
+            this._templating.hideSpinner(id);
+        },
+
+        _onAllComplete: function(successful, failed) {
+            this._parent.prototype._onAllComplete.apply(this, arguments);
+            this._templating.resetTotalProgress();
+        },
+
+        _onSubmit: function(id, name) {
+            var file = this.getFile(id);
+
+            if (file && file.qqPath && this._options.dragAndDrop.reportDirectoryPaths) {
+                this._paramsStore.addReadOnly(id, {
+                    qqpath: file.qqPath
+                });
+            }
+
+            this._parent.prototype._onSubmit.apply(this, arguments);
+            this._addToList(id, name);
+        },
+
+        // The file item has been added to the DOM.
+        _onSubmitted: function(id) {
+            // If the edit filename feature is enabled, mark the filename element as "editable" and the associated edit icon
+            if (this._isEditFilenameEnabled()) {
+                this._templating.markFilenameEditable(id);
+                this._templating.showEditIcon(id);
+
+                // If the focusin event is not supported, we must add a focus handler to the newly create edit filename text input
+                if (!this._focusinEventSupported) {
+                    this._filenameInputFocusHandler.addHandler(this._templating.getEditInput(id));
+                }
+            }
+        },
+
+        // Update the progress bar & percentage as the file is uploaded
+        _onProgress: function(id, name, loaded, total) {
+            this._parent.prototype._onProgress.apply(this, arguments);
+
+            this._templating.updateProgress(id, loaded, total);
+
+            if (Math.round(loaded / total * 100) === 100) {
+                this._templating.hideCancel(id);
+                this._templating.hidePause(id);
+                this._templating.hideProgress(id);
+                this._templating.setStatusText(id, this._options.text.waitingForResponse);
+
+                // If ~last byte was sent, display total file size
+                this._displayFileSize(id);
+            }
+            else {
+                // If still uploading, display percentage - total size is actually the total request(s) size
+                this._displayFileSize(id, loaded, total);
+            }
+        },
+
+        _onTotalProgress: function(loaded, total) {
+            this._parent.prototype._onTotalProgress.apply(this, arguments);
+            this._templating.updateTotalProgress(loaded, total);
+        },
+
+        _onComplete: function(id, name, result, xhr) {
+            var parentRetVal = this._parent.prototype._onComplete.apply(this, arguments),
+                templating = this._templating,
+                fileContainer = templating.getFileContainer(id),
+                self = this;
+
+            function completeUpload(result) {
+                // If this file is not represented in the templating module, perhaps it was hidden intentionally.
+                // If so, don't perform any UI-related tasks related to this file.
+                if (!fileContainer) {
+                    return;
+                }
+
+                templating.setStatusText(id);
+
+                qq(fileContainer).removeClass(self._classes.retrying);
+                templating.hideProgress(id);
+
+                if (self.getUploads({id: id}).status !== qq.status.UPLOAD_FAILED) {
+                    templating.hideCancel(id);
+                }
+                templating.hideSpinner(id);
+
+                if (result.success) {
+                    self._markFileAsSuccessful(id);
+                }
+                else {
+                    qq(fileContainer).addClass(self._classes.fail);
+                    templating.showCancel(id);
+
+                    if (templating.isRetryPossible() && !self._preventRetries[id]) {
+                        qq(fileContainer).addClass(self._classes.retryable);
+                        templating.showRetry(id);
+                    }
+                    self._controlFailureTextDisplay(id, result);
+                }
+            }
+
+            // The parent may need to perform some async operation before we can accurately determine the status of the upload.
+            if (parentRetVal instanceof qq.Promise) {
+                parentRetVal.done(function(newResult) {
+                    completeUpload(newResult);
+                });
+
+            }
+            else {
+                completeUpload(result);
+            }
+
+            return parentRetVal;
+        },
+
+        _markFileAsSuccessful: function(id) {
+            var templating = this._templating;
+
+            if (this._isDeletePossible()) {
+                templating.showDeleteButton(id);
+            }
+
+            qq(templating.getFileContainer(id)).addClass(this._classes.success);
+
+            this._maybeUpdateThumbnail(id);
+        },
+
+        _onUploadPrep: function(id) {
+            this._parent.prototype._onUploadPrep.apply(this, arguments);
+            this._templating.showSpinner(id);
+        },
+
+        _onUpload: function(id, name) {
+            var parentRetVal = this._parent.prototype._onUpload.apply(this, arguments);
+
+            this._templating.showSpinner(id);
+
+            return parentRetVal;
+        },
+
+        _onUploadChunk: function(id, chunkData) {
+            this._parent.prototype._onUploadChunk.apply(this, arguments);
+
+            // Only display the pause button if we have finished uploading at least one chunk
+            // & this file can be resumed
+            if (chunkData.partIndex > 0 && this._handler.isResumable(id)) {
+                this._templating.allowPause(id);
+            }
+        },
+
+        _onCancel: function(id, name) {
+            this._parent.prototype._onCancel.apply(this, arguments);
+            this._removeFileItem(id);
+
+            if (this._getNotFinished() === 0) {
+                this._templating.resetTotalProgress();
+            }
+        },
+
+        _onBeforeAutoRetry: function(id) {
+            var retryNumForDisplay, maxAuto, retryNote;
+
+            this._parent.prototype._onBeforeAutoRetry.apply(this, arguments);
+
+            this._showCancelLink(id);
+
+            if (this._options.retry.showAutoRetryNote) {
+                retryNumForDisplay = this._autoRetries[id];
+                maxAuto = this._options.retry.maxAutoAttempts;
+
+                retryNote = this._options.retry.autoRetryNote.replace(/\{retryNum\}/g, retryNumForDisplay);
+                retryNote = retryNote.replace(/\{maxAuto\}/g, maxAuto);
+
+                this._templating.setStatusText(id, retryNote);
+                qq(this._templating.getFileContainer(id)).addClass(this._classes.retrying);
+            }
+        },
+
+        //return false if we should not attempt the requested retry
+        _onBeforeManualRetry: function(id) {
+            if (this._parent.prototype._onBeforeManualRetry.apply(this, arguments)) {
+                this._templating.resetProgress(id);
+                qq(this._templating.getFileContainer(id)).removeClass(this._classes.fail);
+                this._templating.setStatusText(id);
+                this._templating.showSpinner(id);
+                this._showCancelLink(id);
+                return true;
+            }
+            else {
+                qq(this._templating.getFileContainer(id)).addClass(this._classes.retryable);
+                this._templating.showRetry(id);
+                return false;
+            }
+        },
+
+        _onSubmitDelete: function(id) {
+            var onSuccessCallback = qq.bind(this._onSubmitDeleteSuccess, this);
+
+            this._parent.prototype._onSubmitDelete.call(this, id, onSuccessCallback);
+        },
+
+        _onSubmitDeleteSuccess: function(id, uuid, additionalMandatedParams) {
+            if (this._options.deleteFile.forceConfirm) {
+                this._showDeleteConfirm.apply(this, arguments);
+            }
+            else {
+                this._sendDeleteRequest.apply(this, arguments);
+            }
+        },
+
+        _onDeleteComplete: function(id, xhr, isError) {
+            this._parent.prototype._onDeleteComplete.apply(this, arguments);
+
+            this._templating.hideSpinner(id);
+
+            if (isError) {
+                this._templating.setStatusText(id, this._options.deleteFile.deletingFailedText);
+                this._templating.showDeleteButton(id);
+            }
+            else {
+                this._removeFileItem(id);
+            }
+        },
+
+        _sendDeleteRequest: function(id, uuid, additionalMandatedParams) {
+            this._templating.hideDeleteButton(id);
+            this._templating.showSpinner(id);
+            this._templating.setStatusText(id, this._options.deleteFile.deletingStatusText);
+            this._deleteHandler.sendDelete.apply(this, arguments);
+        },
+
+        _showDeleteConfirm: function(id, uuid, mandatedParams) {
+            /*jshint -W004 */
+            var fileName = this.getName(id),
+                confirmMessage = this._options.deleteFile.confirmMessage.replace(/\{filename\}/g, fileName),
+                uuid = this.getUuid(id),
+                deleteRequestArgs = arguments,
+                self = this,
+                retVal;
+
+            retVal = this._options.showConfirm(confirmMessage);
+
+            if (qq.isGenericPromise(retVal)) {
+                retVal.then(function() {
+                    self._sendDeleteRequest.apply(self, deleteRequestArgs);
+                });
+            }
+            else if (retVal !== false) {
+                self._sendDeleteRequest.apply(self, deleteRequestArgs);
+            }
+        },
+
+        _addToList: function(id, name, canned) {
+            var prependData,
+                prependIndex = 0,
+                dontDisplay = this._handler.isProxied(id) && this._options.scaling.hideScaled,
+                record;
+
+            // If we don't want this file to appear in the UI, skip all of this UI-related logic.
+            if (dontDisplay) {
+                return;
+            }
+
+            if (this._options.display.prependFiles) {
+                if (this._totalFilesInBatch > 1 && this._filesInBatchAddedToUi > 0) {
+                    prependIndex = this._filesInBatchAddedToUi - 1;
+                }
+
+                prependData = {
+                    index: prependIndex
+                };
+            }
+
+            if (!canned) {
+                if (this._options.disableCancelForFormUploads && !qq.supportedFeatures.ajaxUploading) {
+                    this._templating.disableCancel();
+                }
+
+                // Cancel all existing (previous) files and clear the list if this file is not part of
+                // a scaled file group that has already been accepted, or if this file is not part of
+                // a scaled file group at all.
+                if (!this._options.multiple) {
+                    record = this.getUploads({id: id});
+
+                    this._handledProxyGroup = this._handledProxyGroup || record.proxyGroupId;
+
+                    if (record.proxyGroupId !== this._handledProxyGroup || !record.proxyGroupId) {
+                        this._handler.cancelAll();
+                        this._clearList();
+                        this._handledProxyGroup = null;
+                    }
+                }
+            }
+
+            this._templating.addFile(id, this._options.formatFileName(name), prependData);
+
+            if (canned) {
+                this._thumbnailUrls[id] && this._templating.updateThumbnail(id, this._thumbnailUrls[id], true);
+            }
+            else {
+                this._templating.generatePreview(id, this.getFile(id));
+            }
+
+            this._filesInBatchAddedToUi += 1;
+
+            if (canned ||
+                (this._options.display.fileSizeOnSubmit && qq.supportedFeatures.ajaxUploading)) {
+
+                this._displayFileSize(id);
+            }
+        },
+
+        _clearList: function() {
+            this._templating.clearFiles();
+            this.clearStoredFiles();
+        },
+
+        _displayFileSize: function(id, loadedSize, totalSize) {
+            var size = this.getSize(id),
+                sizeForDisplay = this._formatSize(size);
+
+            if (size >= 0) {
+                if (loadedSize !== undefined && totalSize !== undefined) {
+                    sizeForDisplay = this._formatProgress(loadedSize, totalSize);
+                }
+
+                this._templating.updateSize(id, sizeForDisplay);
+            }
+        },
+
+        _formatProgress: function(uploadedSize, totalSize) {
+            var message = this._options.text.formatProgress;
+            function r(name, replacement) { message = message.replace(name, replacement); }
+
+            r("{percent}", Math.round(uploadedSize / totalSize * 100));
+            r("{total_size}", this._formatSize(totalSize));
+            return message;
+        },
+
+        _controlFailureTextDisplay: function(id, response) {
+            var mode, responseProperty, failureReason;
+
+            mode = this._options.failedUploadTextDisplay.mode;
+            responseProperty = this._options.failedUploadTextDisplay.responseProperty;
+
+            if (mode === "custom") {
+                failureReason = response[responseProperty];
+                if (!failureReason) {
+                    failureReason = this._options.text.failUpload;
+                }
+
+                this._templating.setStatusText(id, failureReason);
+
+                if (this._options.failedUploadTextDisplay.enableTooltip) {
+                    this._showTooltip(id, failureReason);
+                }
+            }
+            else if (mode === "default") {
+                this._templating.setStatusText(id, this._options.text.failUpload);
+            }
+            else if (mode !== "none") {
+                this.log("failedUploadTextDisplay.mode value of '" + mode + "' is not valid", "warn");
+            }
+        },
+
+        _showTooltip: function(id, text) {
+            this._templating.getFileContainer(id).title = text;
+        },
+
+        _showCancelLink: function(id) {
+            if (!this._options.disableCancelForFormUploads || qq.supportedFeatures.ajaxUploading) {
+                this._templating.showCancel(id);
+            }
+        },
+
+        _itemError: function(code, name, item) {
+            var message = this._parent.prototype._itemError.apply(this, arguments);
+            this._options.showMessage(message);
+        },
+
+        _batchError: function(message) {
+            this._parent.prototype._batchError.apply(this, arguments);
+            this._options.showMessage(message);
+        },
+
+        _setupPastePrompt: function() {
+            var self = this;
+
+            this._options.callbacks.onPasteReceived = function() {
+                var message = self._options.paste.namePromptMessage,
+                    defaultVal = self._options.paste.defaultName;
+
+                return self._options.showPrompt(message, defaultVal);
+            };
+        },
+
+        _fileOrBlobRejected: function(id, name) {
+            this._totalFilesInBatch -= 1;
+            this._parent.prototype._fileOrBlobRejected.apply(this, arguments);
+        },
+
+        _prepareItemsForUpload: function(items, params, endpoint) {
+            this._totalFilesInBatch = items.length;
+            this._filesInBatchAddedToUi = 0;
+            this._parent.prototype._prepareItemsForUpload.apply(this, arguments);
+        },
+
+        _maybeUpdateThumbnail: function(fileId) {
+            var thumbnailUrl = this._thumbnailUrls[fileId],
+                fileStatus = this.getUploads({id: fileId}).status;
+
+            if (fileStatus !== qq.status.DELETED &&
+                (thumbnailUrl ||
+                this._options.thumbnails.placeholders.waitUntilResponse ||
+                !qq.supportedFeatures.imagePreviews)) {
+
+                // This will replace the "waiting" placeholder with a "preview not available" placeholder
+                // if called with a null thumbnailUrl.
+                this._templating.updateThumbnail(fileId, thumbnailUrl);
+            }
+        },
+
+        _addCannedFile: function(sessionData) {
+            var id = this._parent.prototype._addCannedFile.apply(this, arguments);
+
+            this._addToList(id, this.getName(id), true);
+            this._templating.hideSpinner(id);
+            this._templating.hideCancel(id);
+            this._markFileAsSuccessful(id);
+
+            return id;
+        },
+
+        _setSize: function(id, newSize) {
+            this._parent.prototype._setSize.apply(this, arguments);
+
+            this._templating.updateSize(id, this._formatSize(newSize));
+        }
+    };
+}());
+
+/*globals qq */
+/**
+ * This defines FineUploader mode, which is a default UI w/ drag & drop uploading.
+ */
+qq.FineUploader = function(o, namespace) {
+    "use strict";
+
+    var self = this;
+
+    // By default this should inherit instance data from FineUploaderBasic, but this can be overridden
+    // if the (internal) caller defines a different parent.  The parent is also used by
+    // the private and public API functions that need to delegate to a parent function.
+    this._parent = namespace ? qq[namespace].FineUploaderBasic : qq.FineUploaderBasic;
+    this._parent.apply(this, arguments);
+
+    // Options provided by FineUploader mode
+    qq.extend(this._options, {
+        element: null,
+
+        button: null,
+
+        listElement: null,
+
+        dragAndDrop: {
+            extraDropzones: [],
+            reportDirectoryPaths: false
+        },
+
+        text: {
+            formatProgress: "{percent}% of {total_size}",
+            failUpload: "Upload failed",
+            waitingForResponse: "Processing...",
+            paused: "Paused"
+        },
+
+        template: "qq-template",
+
+        classes: {
+            retrying: "qq-upload-retrying",
+            retryable: "qq-upload-retryable",
+            success: "qq-upload-success",
+            fail: "qq-upload-fail",
+            editable: "qq-editable",
+            hide: "qq-hide",
+            dropActive: "qq-upload-drop-area-active"
+        },
+
+        failedUploadTextDisplay: {
+            mode: "default", //default, custom, or none
+            responseProperty: "error",
+            enableTooltip: true
+        },
+
+        messages: {
+            tooManyFilesError: "You may only drop one file",
+            unsupportedBrowser: "Unrecoverable error - this browser does not permit file uploading of any kind."
+        },
+
+        retry: {
+            showAutoRetryNote: true,
+            autoRetryNote: "Retrying {retryNum}/{maxAuto}..."
+        },
+
+        deleteFile: {
+            forceConfirm: false,
+            confirmMessage: "Are you sure you want to delete {filename}?",
+            deletingStatusText: "Deleting...",
+            deletingFailedText: "Delete failed"
+
+        },
+
+        display: {
+            fileSizeOnSubmit: false,
+            prependFiles: false
+        },
+
+        paste: {
+            promptForName: false,
+            namePromptMessage: "Please name this image"
+        },
+
+        thumbnails: {
+            maxCount: 0,
+            placeholders: {
+                waitUntilResponse: false,
+                notAvailablePath: null,
+                waitingPath: null
+            },
+            timeBetweenThumbs: 750
+        },
+
+        scaling: {
+            hideScaled: false
+        },
+
+        showMessage: function(message) {
+            if (self._templating.hasDialog("alert")) {
+                return self._templating.showDialog("alert", message);
+            }
+            else {
+                setTimeout(function() {
+                    window.alert(message);
+                }, 0);
+            }
+        },
+
+        showConfirm: function(message) {
+            if (self._templating.hasDialog("confirm")) {
+                return self._templating.showDialog("confirm", message);
+            }
+            else {
+                return window.confirm(message);
+            }
+        },
+
+        showPrompt: function(message, defaultValue) {
+            if (self._templating.hasDialog("prompt")) {
+                return self._templating.showDialog("prompt", message, defaultValue);
+            }
+            else {
+                return window.prompt(message, defaultValue);
+            }
+        }
+    }, true);
+
+    // Replace any default options with user defined ones
+    qq.extend(this._options, o, true);
+
+    this._templating = new qq.Templating({
+        log: qq.bind(this.log, this),
+        templateIdOrEl: this._options.template,
+        containerEl: this._options.element,
+        fileContainerEl: this._options.listElement,
+        button: this._options.button,
+        imageGenerator: this._imageGenerator,
+        classes: {
+            hide: this._options.classes.hide,
+            editable: this._options.classes.editable
+        },
+        limits: {
+            maxThumbs: this._options.thumbnails.maxCount,
+            timeBetweenThumbs: this._options.thumbnails.timeBetweenThumbs
+        },
+        placeholders: {
+            waitUntilUpdate: this._options.thumbnails.placeholders.waitUntilResponse,
+            thumbnailNotAvailable: this._options.thumbnails.placeholders.notAvailablePath,
+            waitingForThumbnail: this._options.thumbnails.placeholders.waitingPath
+        },
+        text: this._options.text
+    });
+
+    if (this._options.workarounds.ios8SafariUploads && qq.ios800() && qq.iosSafari()) {
+        this._templating.renderFailure(this._options.messages.unsupportedBrowserIos8Safari);
+    }
+    else if (!qq.supportedFeatures.uploading || (this._options.cors.expected && !qq.supportedFeatures.uploadCors)) {
+        this._templating.renderFailure(this._options.messages.unsupportedBrowser);
+    }
+    else {
+        this._wrapCallbacks();
+
+        this._templating.render();
+
+        this._classes = this._options.classes;
+
+        if (!this._options.button && this._templating.getButton()) {
+            this._defaultButtonId = this._createUploadButton({element: this._templating.getButton()}).getButtonId();
+        }
+
+        this._setupClickAndEditEventHandlers();
+
+        if (qq.DragAndDrop && qq.supportedFeatures.fileDrop) {
+            this._dnd = this._setupDragAndDrop();
+        }
+
+        if (this._options.paste.targetElement && this._options.paste.promptForName) {
+            if (qq.PasteSupport) {
+                this._setupPastePrompt();
+            }
+            else {
+                this.log("Paste support module not found.", "error");
+            }
+        }
+
+        this._totalFilesInBatch = 0;
+        this._filesInBatchAddedToUi = 0;
+    }
+};
+
+// Inherit the base public & private API methods
+qq.extend(qq.FineUploader.prototype, qq.basePublicApi);
+qq.extend(qq.FineUploader.prototype, qq.basePrivateApi);
+
+// Add the FineUploader/default UI public & private UI methods, which may override some base methods.
+qq.extend(qq.FineUploader.prototype, qq.uiPublicApi);
+qq.extend(qq.FineUploader.prototype, qq.uiPrivateApi);
+
+/* globals qq */
+/* jshint -W065 */
+/**
+ * Module responsible for rendering all Fine Uploader UI templates.  This module also asserts at least
+ * a limited amount of control over the template elements after they are added to the DOM.
+ * Wherever possible, this module asserts total control over template elements present in the DOM.
+ *
+ * @param spec Specification object used to control various templating behaviors
+ * @constructor
+ */
+qq.Templating = function(spec) {
+    "use strict";
+
+    var FILE_ID_ATTR = "qq-file-id",
+        FILE_CLASS_PREFIX = "qq-file-id-",
+        THUMBNAIL_MAX_SIZE_ATTR = "qq-max-size",
+        THUMBNAIL_SERVER_SCALE_ATTR = "qq-server-scale",
+        // This variable is duplicated in the DnD module since it can function as a standalone as well
+        HIDE_DROPZONE_ATTR = "qq-hide-dropzone",
+        DROPZPONE_TEXT_ATTR = "qq-drop-area-text",
+        IN_PROGRESS_CLASS = "qq-in-progress",
+        isCancelDisabled = false,
+        generatedThumbnails = 0,
+        thumbnailQueueMonitorRunning = false,
+        thumbGenerationQueue = [],
+        thumbnailMaxSize = -1,
+        options = {
+            log: null,
+            limits: {
+                maxThumbs: 0,
+                timeBetweenThumbs: 750
+            },
+            templateIdOrEl: "qq-template",
+            containerEl: null,
+            fileContainerEl: null,
+            button: null,
+            imageGenerator: null,
+            classes: {
+                hide: "qq-hide",
+                editable: "qq-editable"
+            },
+            placeholders: {
+                waitUntilUpdate: false,
+                thumbnailNotAvailable: null,
+                waitingForThumbnail: null
+            },
+            text: {
+                paused: "Paused"
+            }
+        },
+        selectorClasses = {
+            button: "qq-upload-button-selector",
+            alertDialog: "qq-alert-dialog-selector",
+            dialogCancelButton: "qq-cancel-button-selector",
+            confirmDialog: "qq-confirm-dialog-selector",
+            dialogMessage: "qq-dialog-message-selector",
+            dialogOkButton: "qq-ok-button-selector",
+            promptDialog: "qq-prompt-dialog-selector",
+            uploader: "qq-uploader-selector",
+            drop: "qq-upload-drop-area-selector",
+            list: "qq-upload-list-selector",
+            progressBarContainer: "qq-progress-bar-container-selector",
+            progressBar: "qq-progress-bar-selector",
+            totalProgressBarContainer: "qq-total-progress-bar-container-selector",
+            totalProgressBar: "qq-total-progress-bar-selector",
+            file: "qq-upload-file-selector",
+            spinner: "qq-upload-spinner-selector",
+            size: "qq-upload-size-selector",
+            cancel: "qq-upload-cancel-selector",
+            pause: "qq-upload-pause-selector",
+            continueButton: "qq-upload-continue-selector",
+            deleteButton: "qq-upload-delete-selector",
+            retry: "qq-upload-retry-selector",
+            statusText: "qq-upload-status-text-selector",
+            editFilenameInput: "qq-edit-filename-selector",
+            editNameIcon: "qq-edit-filename-icon-selector",
+            dropText: "qq-upload-drop-area-text-selector",
+            dropProcessing: "qq-drop-processing-selector",
+            dropProcessingSpinner: "qq-drop-processing-spinner-selector",
+            thumbnail: "qq-thumbnail-selector"
+        },
+        previewGeneration = {},
+        cachedThumbnailNotAvailableImg = new qq.Promise(),
+        cachedWaitingForThumbnailImg = new qq.Promise(),
+        log,
+        isEditElementsExist,
+        isRetryElementExist,
+        templateHtml,
+        container,
+        fileList,
+        showThumbnails,
+        serverScale,
+
+        // During initialization of the templating module we should cache any
+        // placeholder images so we can quickly swap them into the file list on demand.
+        // Any placeholder images that cannot be loaded/found are simply ignored.
+        cacheThumbnailPlaceholders = function() {
+            var notAvailableUrl =  options.placeholders.thumbnailNotAvailable,
+                waitingUrl = options.placeholders.waitingForThumbnail,
+                spec = {
+                    maxSize: thumbnailMaxSize,
+                    scale: serverScale
+                };
+
+            if (showThumbnails) {
+                if (notAvailableUrl) {
+                    options.imageGenerator.generate(notAvailableUrl, new Image(), spec).then(
+                        function(updatedImg) {
+                            cachedThumbnailNotAvailableImg.success(updatedImg);
+                        },
+                        function() {
+                            cachedThumbnailNotAvailableImg.failure();
+                            log("Problem loading 'not available' placeholder image at " + notAvailableUrl, "error");
+                        }
+                    );
+                }
+                else {
+                    cachedThumbnailNotAvailableImg.failure();
+                }
+
+                if (waitingUrl) {
+                    options.imageGenerator.generate(waitingUrl, new Image(), spec).then(
+                        function(updatedImg) {
+                            cachedWaitingForThumbnailImg.success(updatedImg);
+                        },
+                        function() {
+                            cachedWaitingForThumbnailImg.failure();
+                            log("Problem loading 'waiting for thumbnail' placeholder image at " + waitingUrl, "error");
+                        }
+                    );
+                }
+                else {
+                    cachedWaitingForThumbnailImg.failure();
+                }
+            }
+        },
+
+        // Displays a "waiting for thumbnail" type placeholder image
+        // iff we were able to load it during initialization of the templating module.
+        displayWaitingImg = function(thumbnail) {
+            var waitingImgPlacement = new qq.Promise();
+
+            cachedWaitingForThumbnailImg.then(function(img) {
+                maybeScalePlaceholderViaCss(img, thumbnail);
+                /* jshint eqnull:true */
+                if (!thumbnail.src) {
+                    thumbnail.src = img.src;
+                    thumbnail.onload = function() {
+                        thumbnail.onload = null;
+                        show(thumbnail);
+                        waitingImgPlacement.success();
+                    };
+                }
+                else {
+                    waitingImgPlacement.success();
+                }
+            }, function() {
+                // In some browsers (such as IE9 and older) an img w/out a src attribute
+                // are displayed as "broken" images, so we should just hide the img tag
+                // if we aren't going to display the "waiting" placeholder.
+                hide(thumbnail);
+                waitingImgPlacement.success();
+            });
+
+            return waitingImgPlacement;
+        },
+
+        generateNewPreview = function(id, blob, spec) {
+            var thumbnail = getThumbnail(id);
+
+            log("Generating new thumbnail for " + id);
+            blob.qqThumbnailId = id;
+
+            return options.imageGenerator.generate(blob, thumbnail, spec).then(
+                function() {
+                    generatedThumbnails++;
+                    show(thumbnail);
+                    previewGeneration[id].success();
+                },
+                function() {
+                    previewGeneration[id].failure();
+
+                    // Display the "not available" placeholder img only if we are
+                    // not expecting a thumbnail at a later point, such as in a server response.
+                    if (!options.placeholders.waitUntilUpdate) {
+                        maybeSetDisplayNotAvailableImg(id, thumbnail);
+                    }
+                });
+        },
+
+        generateNextQueuedPreview = function() {
+            if (thumbGenerationQueue.length) {
+                thumbnailQueueMonitorRunning = true;
+
+                var queuedThumbRequest = thumbGenerationQueue.shift();
+
+                if (queuedThumbRequest.update) {
+                    processUpdateQueuedPreviewRequest(queuedThumbRequest);
+                }
+                else {
+                    processNewQueuedPreviewRequest(queuedThumbRequest);
+                }
+            }
+            else {
+                thumbnailQueueMonitorRunning = false;
+            }
+        },
+
+        getCancel = function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.cancel);
+        },
+
+        getContinue = function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.continueButton);
+        },
+
+        getDialog = function(type) {
+            return getTemplateEl(container, selectorClasses[type + "Dialog"]);
+        },
+
+        getDelete = function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.deleteButton);
+        },
+
+        getDropProcessing = function() {
+            return getTemplateEl(container, selectorClasses.dropProcessing);
+        },
+
+        getEditIcon = function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.editNameIcon);
+        },
+
+        getFile = function(id) {
+            return qq(fileList).getByClass(FILE_CLASS_PREFIX + id)[0];
+        },
+
+        getFilename = function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.file);
+        },
+
+        getPause = function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.pause);
+        },
+
+        getProgress = function(id) {
+            /* jshint eqnull:true */
+            // Total progress bar
+            if (id == null) {
+                return getTemplateEl(container, selectorClasses.totalProgressBarContainer) ||
+                    getTemplateEl(container, selectorClasses.totalProgressBar);
+            }
+
+            // Per-file progress bar
+            return getTemplateEl(getFile(id), selectorClasses.progressBarContainer) ||
+                getTemplateEl(getFile(id), selectorClasses.progressBar);
+        },
+
+        getRetry = function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.retry);
+        },
+
+        getSize = function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.size);
+        },
+
+        getSpinner = function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.spinner);
+        },
+
+        getTemplateEl = function(context, cssClass) {
+            return context && qq(context).getByClass(cssClass)[0];
+        },
+
+        getThumbnail = function(id) {
+            return showThumbnails && getTemplateEl(getFile(id), selectorClasses.thumbnail);
+        },
+
+        hide = function(el) {
+            el && qq(el).addClass(options.classes.hide);
+        },
+
+        // Ensures a placeholder image does not exceed any max size specified
+        // via `style` attribute properties iff <canvas> was not used to scale
+        // the placeholder AND the target <img> doesn't already have these `style` attribute properties set.
+        maybeScalePlaceholderViaCss = function(placeholder, thumbnail) {
+            var maxWidth = placeholder.style.maxWidth,
+                maxHeight = placeholder.style.maxHeight;
+
+            if (maxHeight && maxWidth && !thumbnail.style.maxWidth && !thumbnail.style.maxHeight) {
+                qq(thumbnail).css({
+                    maxWidth: maxWidth,
+                    maxHeight: maxHeight
+                });
+            }
+        },
+
+        // Displays a "thumbnail not available" type placeholder image
+        // iff we were able to load this placeholder during initialization
+        // of the templating module or after preview generation has failed.
+        maybeSetDisplayNotAvailableImg = function(id, thumbnail) {
+            var previewing = previewGeneration[id] || new qq.Promise().failure(),
+                notAvailableImgPlacement = new qq.Promise();
+
+            cachedThumbnailNotAvailableImg.then(function(img) {
+                previewing.then(
+                    function() {
+                        notAvailableImgPlacement.success();
+                    },
+                    function() {
+                        maybeScalePlaceholderViaCss(img, thumbnail);
+
+                        thumbnail.onload = function() {
+                            thumbnail.onload = null;
+                            notAvailableImgPlacement.success();
+                        };
+
+                        thumbnail.src = img.src;
+                        show(thumbnail);
+                    }
+                );
+            });
+
+            return notAvailableImgPlacement;
+        },
+
+        /**
+         * Grabs the HTML from the script tag holding the template markup.  This function will also adjust
+         * some internally-tracked state variables based on the contents of the template.
+         * The template is filtered so that irrelevant elements (such as the drop zone if DnD is not supported)
+         * are omitted from the DOM.  Useful errors will be thrown if the template cannot be parsed.
+         *
+         * @returns {{template: *, fileTemplate: *}} HTML for the top-level file items templates
+         */
+        parseAndGetTemplate = function() {
+            var scriptEl,
+                scriptHtml,
+                fileListNode,
+                tempTemplateEl,
+                fileListHtml,
+                defaultButton,
+                dropArea,
+                thumbnail,
+                dropProcessing,
+                dropTextEl,
+                uploaderEl;
+
+            log("Parsing template");
+
+            /*jshint -W116*/
+            if (options.templateIdOrEl == null) {
+                throw new Error("You MUST specify either a template element or ID!");
+            }
+
+            // Grab the contents of the script tag holding the template.
+            if (qq.isString(options.templateIdOrEl)) {
+                scriptEl = document.getElementById(options.templateIdOrEl);
+
+                if (scriptEl === null) {
+                    throw new Error(qq.format("Cannot find template script at ID '{}'!", options.templateIdOrEl));
+                }
+
+                scriptHtml = scriptEl.innerHTML;
+            }
+            else {
+                if (options.templateIdOrEl.innerHTML === undefined) {
+                    throw new Error("You have specified an invalid value for the template option!  " +
+                        "It must be an ID or an Element.");
+                }
+
+                scriptHtml = options.templateIdOrEl.innerHTML;
+            }
+
+            scriptHtml = qq.trimStr(scriptHtml);
+            tempTemplateEl = document.createElement("div");
+            tempTemplateEl.appendChild(qq.toElement(scriptHtml));
+            uploaderEl = qq(tempTemplateEl).getByClass(selectorClasses.uploader)[0];
+
+            // Don't include the default template button in the DOM
+            // if an alternate button container has been specified.
+            if (options.button) {
+                defaultButton = qq(tempTemplateEl).getByClass(selectorClasses.button)[0];
+                if (defaultButton) {
+                    qq(defaultButton).remove();
+                }
+            }
+
+            // Omit the drop processing element from the DOM if DnD is not supported by the UA,
+            // or the drag and drop module is not found.
+            // NOTE: We are consciously not removing the drop zone if the UA doesn't support DnD
+            // to support layouts where the drop zone is also a container for visible elements,
+            // such as the file list.
+            if (!qq.DragAndDrop || !qq.supportedFeatures.fileDrop) {
+                dropProcessing = qq(tempTemplateEl).getByClass(selectorClasses.dropProcessing)[0];
+                if (dropProcessing) {
+                    qq(dropProcessing).remove();
+                }
+            }
+
+            dropArea = qq(tempTemplateEl).getByClass(selectorClasses.drop)[0];
+
+            // If DnD is not available then remove
+            // it from the DOM as well.
+            if (dropArea && !qq.DragAndDrop) {
+                log("DnD module unavailable.", "info");
+                qq(dropArea).remove();
+            }
+
+            if (!qq.supportedFeatures.fileDrop) {
+                // don't display any "drop files to upload" background text
+                uploaderEl.removeAttribute(DROPZPONE_TEXT_ATTR);
+
+                if (dropArea && qq(dropArea).hasAttribute(HIDE_DROPZONE_ATTR)) {
+                    // If there is a drop area defined in the template, and the current UA doesn't support DnD,
+                    // and the drop area is marked as "hide before enter", ensure it is hidden as the DnD module
+                    // will not do this (since we will not be loading the DnD module)
+                    qq(dropArea).css({
+                        display: "none"
+                    });
+                }
+            }
+            else if (qq(uploaderEl).hasAttribute(DROPZPONE_TEXT_ATTR) && dropArea) {
+                dropTextEl = qq(dropArea).getByClass(selectorClasses.dropText)[0];
+                dropTextEl && qq(dropTextEl).remove();
+            }
+
+            // Ensure the `showThumbnails` flag is only set if the thumbnail element
+            // is present in the template AND the current UA is capable of generating client-side previews.
+            thumbnail = qq(tempTemplateEl).getByClass(selectorClasses.thumbnail)[0];
+            if (!showThumbnails) {
+                thumbnail && qq(thumbnail).remove();
+            }
+            else if (thumbnail) {
+                thumbnailMaxSize = parseInt(thumbnail.getAttribute(THUMBNAIL_MAX_SIZE_ATTR));
+                // Only enforce max size if the attr value is non-zero
+                thumbnailMaxSize = thumbnailMaxSize > 0 ? thumbnailMaxSize : null;
+
+                serverScale = qq(thumbnail).hasAttribute(THUMBNAIL_SERVER_SCALE_ATTR);
+            }
+            showThumbnails = showThumbnails && thumbnail;
+
+            isEditElementsExist = qq(tempTemplateEl).getByClass(selectorClasses.editFilenameInput).length > 0;
+            isRetryElementExist = qq(tempTemplateEl).getByClass(selectorClasses.retry).length > 0;
+
+            fileListNode = qq(tempTemplateEl).getByClass(selectorClasses.list)[0];
+            /*jshint -W116*/
+            if (fileListNode == null) {
+                throw new Error("Could not find the file list container in the template!");
+            }
+
+            fileListHtml = fileListNode.innerHTML;
+            fileListNode.innerHTML = "";
+
+            // We must call `createElement` in IE8 in order to target and hide any <dialog> via CSS
+            if (tempTemplateEl.getElementsByTagName("DIALOG").length) {
+                document.createElement("dialog");
+            }
+
+            log("Template parsing complete");
+
+            return {
+                template: qq.trimStr(tempTemplateEl.innerHTML),
+                fileTemplate: qq.trimStr(fileListHtml)
+            };
+        },
+
+        prependFile = function(el, index) {
+            var parentEl = fileList,
+                beforeEl = parentEl.firstChild;
+
+            if (index > 0) {
+                beforeEl = qq(parentEl).children()[index].nextSibling;
+
+            }
+
+            parentEl.insertBefore(el, beforeEl);
+        },
+
+        processNewQueuedPreviewRequest = function(queuedThumbRequest) {
+            var id = queuedThumbRequest.id,
+                optFileOrBlob = queuedThumbRequest.optFileOrBlob,
+                relatedThumbnailId = optFileOrBlob && optFileOrBlob.qqThumbnailId,
+                thumbnail = getThumbnail(id),
+                spec = {
+                    maxSize: thumbnailMaxSize,
+                    scale: true,
+                    orient: true
+                };
+
+            if (qq.supportedFeatures.imagePreviews) {
+                if (thumbnail) {
+                    if (options.limits.maxThumbs && options.limits.maxThumbs <= generatedThumbnails) {
+                        maybeSetDisplayNotAvailableImg(id, thumbnail);
+                        generateNextQueuedPreview();
+                    }
+                    else {
+                        displayWaitingImg(thumbnail).done(function() {
+                            previewGeneration[id] = new qq.Promise();
+
+                            previewGeneration[id].done(function() {
+                                setTimeout(generateNextQueuedPreview, options.limits.timeBetweenThumbs);
+                            });
+
+                            /* jshint eqnull: true */
+                            // If we've already generated an <img> for this file, use the one that exists,
+                            // don't waste resources generating a new one.
+                            if (relatedThumbnailId != null) {
+                                useCachedPreview(id, relatedThumbnailId);
+                            }
+                            else {
+                                generateNewPreview(id, optFileOrBlob, spec);
+                            }
+                        });
+                    }
+                }
+                // File element in template may have been removed, so move on to next item in queue
+                else {
+                    generateNextQueuedPreview();
+                }
+            }
+            else if (thumbnail) {
+                displayWaitingImg(thumbnail);
+                generateNextQueuedPreview();
+            }
+        },
+
+        processUpdateQueuedPreviewRequest = function(queuedThumbRequest) {
+            var id = queuedThumbRequest.id,
+                thumbnailUrl = queuedThumbRequest.thumbnailUrl,
+                showWaitingImg = queuedThumbRequest.showWaitingImg,
+                thumbnail = getThumbnail(id),
+                spec = {
+                    maxSize: thumbnailMaxSize,
+                    scale: serverScale
+                };
+
+            if (thumbnail) {
+                if (thumbnailUrl) {
+                    if (options.limits.maxThumbs && options.limits.maxThumbs <= generatedThumbnails) {
+                        maybeSetDisplayNotAvailableImg(id, thumbnail);
+                        generateNextQueuedPreview();
+                    }
+                    else {
+                        if (showWaitingImg) {
+                            displayWaitingImg(thumbnail);
+                        }
+
+                        return options.imageGenerator.generate(thumbnailUrl, thumbnail, spec).then(
+                            function() {
+                                show(thumbnail);
+                                generatedThumbnails++;
+                                setTimeout(generateNextQueuedPreview, options.limits.timeBetweenThumbs);
+                            },
+
+                            function() {
+                                maybeSetDisplayNotAvailableImg(id, thumbnail);
+                                setTimeout(generateNextQueuedPreview, options.limits.timeBetweenThumbs);
+                            }
+                        );
+                    }
+                }
+                else {
+                    maybeSetDisplayNotAvailableImg(id, thumbnail);
+                    generateNextQueuedPreview();
+                }
+            }
+        },
+
+        setProgressBarWidth = function(id, percent) {
+            var bar = getProgress(id),
+                /* jshint eqnull:true */
+                progressBarSelector = id == null ? selectorClasses.totalProgressBar : selectorClasses.progressBar;
+
+            if (bar && !qq(bar).hasClass(progressBarSelector)) {
+                bar = qq(bar).getByClass(progressBarSelector)[0];
+            }
+
+            if (bar) {
+                qq(bar).css({width: percent + "%"});
+                bar.setAttribute("aria-valuenow", percent);
+            }
+        },
+
+        show = function(el) {
+            el && qq(el).removeClass(options.classes.hide);
+        },
+
+        useCachedPreview = function(targetThumbnailId, cachedThumbnailId) {
+            var targetThumnail = getThumbnail(targetThumbnailId),
+                cachedThumbnail = getThumbnail(cachedThumbnailId);
+
+            log(qq.format("ID {} is the same file as ID {}.  Will use generated thumbnail from ID {} instead.", targetThumbnailId, cachedThumbnailId, cachedThumbnailId));
+
+            // Generation of the related thumbnail may still be in progress, so, wait until it is done.
+            previewGeneration[cachedThumbnailId].then(function() {
+                generatedThumbnails++;
+                previewGeneration[targetThumbnailId].success();
+                log(qq.format("Now using previously generated thumbnail created for ID {} on ID {}.", cachedThumbnailId, targetThumbnailId));
+                targetThumnail.src = cachedThumbnail.src;
+                show(targetThumnail);
+            },
+            function() {
+                previewGeneration[targetThumbnailId].failure();
+                if (!options.placeholders.waitUntilUpdate) {
+                    maybeSetDisplayNotAvailableImg(targetThumbnailId, targetThumnail);
+                }
+            });
+        };
+
+    qq.extend(options, spec);
+    log = options.log;
+
+    // No need to worry about conserving CPU or memory on older browsers,
+    // since there is no ability to preview, and thumbnail display is primitive and quick.
+    if (!qq.supportedFeatures.imagePreviews) {
+        options.limits.timeBetweenThumbs = 0;
+        options.limits.maxThumbs = 0;
+    }
+
+    container = options.containerEl;
+    showThumbnails = options.imageGenerator !== undefined;
+    templateHtml = parseAndGetTemplate();
+
+    cacheThumbnailPlaceholders();
+
+    qq.extend(this, {
+        render: function() {
+            log("Rendering template in DOM.");
+
+            generatedThumbnails = 0;
+
+            container.innerHTML = templateHtml.template;
+            hide(getDropProcessing());
+            this.hideTotalProgress();
+            fileList = options.fileContainerEl || getTemplateEl(container, selectorClasses.list);
+
+            log("Template rendering complete");
+        },
+
+        renderFailure: function(message) {
+            var cantRenderEl = qq.toElement(message);
+            container.innerHTML = "";
+            container.appendChild(cantRenderEl);
+        },
+
+        reset: function() {
+            this.render();
+        },
+
+        clearFiles: function() {
+            fileList.innerHTML = "";
+        },
+
+        disableCancel: function() {
+            isCancelDisabled = true;
+        },
+
+        addFile: function(id, name, prependInfo) {
+            var fileEl = qq.toElement(templateHtml.fileTemplate),
+                fileNameEl = getTemplateEl(fileEl, selectorClasses.file),
+                uploaderEl = getTemplateEl(container, selectorClasses.uploader),
+                thumb;
+
+            qq(fileEl).addClass(FILE_CLASS_PREFIX + id);
+            uploaderEl.removeAttribute(DROPZPONE_TEXT_ATTR);
+
+            if (fileNameEl) {
+                qq(fileNameEl).setText(name);
+                fileNameEl.setAttribute("title", name);
+            }
+
+            fileEl.setAttribute(FILE_ID_ATTR, id);
+
+            if (prependInfo) {
+                prependFile(fileEl, prependInfo.index);
+            }
+            else {
+                fileList.appendChild(fileEl);
+            }
+
+            hide(getProgress(id));
+            hide(getSize(id));
+            hide(getDelete(id));
+            hide(getRetry(id));
+            hide(getPause(id));
+            hide(getContinue(id));
+
+            if (isCancelDisabled) {
+                this.hideCancel(id);
+            }
+
+            thumb = getThumbnail(id);
+            if (thumb && !thumb.src) {
+                cachedWaitingForThumbnailImg.then(function(waitingImg) {
+                    thumb.src = waitingImg.src;
+                    if (waitingImg.style.maxHeight && waitingImg.style.maxWidth) {
+                        qq(thumb).css({
+                            maxHeight: waitingImg.style.maxHeight,
+                            maxWidth: waitingImg.style.maxWidth
+                        });
+                    }
+
+                    show(thumb);
+                });
+            }
+        },
+
+        removeFile: function(id) {
+            qq(getFile(id)).remove();
+        },
+
+        getFileId: function(el) {
+            var currentNode = el;
+
+            if (currentNode) {
+                /*jshint -W116*/
+                while (currentNode.getAttribute(FILE_ID_ATTR) == null) {
+                    currentNode = currentNode.parentNode;
+                }
+
+                return parseInt(currentNode.getAttribute(FILE_ID_ATTR));
+            }
+        },
+
+        getFileList: function() {
+            return fileList;
+        },
+
+        markFilenameEditable: function(id) {
+            var filename = getFilename(id);
+
+            filename && qq(filename).addClass(options.classes.editable);
+        },
+
+        updateFilename: function(id, name) {
+            var filenameEl = getFilename(id);
+
+            if (filenameEl) {
+                qq(filenameEl).setText(name);
+                filenameEl.setAttribute("title", name);
+            }
+        },
+
+        hideFilename: function(id) {
+            hide(getFilename(id));
+        },
+
+        showFilename: function(id) {
+            show(getFilename(id));
+        },
+
+        isFileName: function(el) {
+            return qq(el).hasClass(selectorClasses.file);
+        },
+
+        getButton: function() {
+            return options.button || getTemplateEl(container, selectorClasses.button);
+        },
+
+        hideDropProcessing: function() {
+            hide(getDropProcessing());
+        },
+
+        showDropProcessing: function() {
+            show(getDropProcessing());
+        },
+
+        getDropZone: function() {
+            return getTemplateEl(container, selectorClasses.drop);
+        },
+
+        isEditFilenamePossible: function() {
+            return isEditElementsExist;
+        },
+
+        hideRetry: function(id) {
+            hide(getRetry(id));
+        },
+
+        isRetryPossible: function() {
+            return isRetryElementExist;
+        },
+
+        showRetry: function(id) {
+            show(getRetry(id));
+        },
+
+        getFileContainer: function(id) {
+            return getFile(id);
+        },
+
+        showEditIcon: function(id) {
+            var icon = getEditIcon(id);
+
+            icon && qq(icon).addClass(options.classes.editable);
+        },
+
+        hideEditIcon: function(id) {
+            var icon = getEditIcon(id);
+
+            icon && qq(icon).removeClass(options.classes.editable);
+        },
+
+        isEditIcon: function(el) {
+            return qq(el).hasClass(selectorClasses.editNameIcon, true);
+        },
+
+        getEditInput: function(id) {
+            return getTemplateEl(getFile(id), selectorClasses.editFilenameInput);
+        },
+
+        isEditInput: function(el) {
+            return qq(el).hasClass(selectorClasses.editFilenameInput, true);
+        },
+
+        updateProgress: function(id, loaded, total) {
+            var bar = getProgress(id),
+                percent;
+
+            if (bar && total > 0) {
+                percent = Math.round(loaded / total * 100);
+
+                if (percent === 100) {
+                    hide(bar);
+                }
+                else {
+                    show(bar);
+                }
+
+                setProgressBarWidth(id, percent);
+            }
+        },
+
+        updateTotalProgress: function(loaded, total) {
+            this.updateProgress(null, loaded, total);
+        },
+
+        hideProgress: function(id) {
+            var bar = getProgress(id);
+
+            bar && hide(bar);
+        },
+
+        hideTotalProgress: function() {
+            this.hideProgress();
+        },
+
+        resetProgress: function(id) {
+            setProgressBarWidth(id, 0);
+            this.hideTotalProgress(id);
+        },
+
+        resetTotalProgress: function() {
+            this.resetProgress();
+        },
+
+        showCancel: function(id) {
+            if (!isCancelDisabled) {
+                var cancel = getCancel(id);
+
+                cancel && qq(cancel).removeClass(options.classes.hide);
+            }
+        },
+
+        hideCancel: function(id) {
+            hide(getCancel(id));
+        },
+
+        isCancel: function(el)  {
+            return qq(el).hasClass(selectorClasses.cancel, true);
+        },
+
+        allowPause: function(id) {
+            show(getPause(id));
+            hide(getContinue(id));
+        },
+
+        uploadPaused: function(id) {
+            this.setStatusText(id, options.text.paused);
+            this.allowContinueButton(id);
+            hide(getSpinner(id));
+        },
+
+        hidePause: function(id) {
+            hide(getPause(id));
+        },
+
+        isPause: function(el) {
+            return qq(el).hasClass(selectorClasses.pause, true);
+        },
+
+        isContinueButton: function(el) {
+            return qq(el).hasClass(selectorClasses.continueButton, true);
+        },
+
+        allowContinueButton: function(id) {
+            show(getContinue(id));
+            hide(getPause(id));
+        },
+
+        uploadContinued: function(id) {
+            this.setStatusText(id, "");
+            this.allowPause(id);
+            show(getSpinner(id));
+        },
+
+        showDeleteButton: function(id) {
+            show(getDelete(id));
+        },
+
+        hideDeleteButton: function(id) {
+            hide(getDelete(id));
+        },
+
+        isDeleteButton: function(el) {
+            return qq(el).hasClass(selectorClasses.deleteButton, true);
+        },
+
+        isRetry: function(el) {
+            return qq(el).hasClass(selectorClasses.retry, true);
+        },
+
+        updateSize: function(id, text) {
+            var size = getSize(id);
+
+            if (size) {
+                show(size);
+                qq(size).setText(text);
+            }
+        },
+
+        setStatusText: function(id, text) {
+            var textEl = getTemplateEl(getFile(id), selectorClasses.statusText);
+
+            if (textEl) {
+                /*jshint -W116*/
+                if (text == null) {
+                    qq(textEl).clearText();
+                }
+                else {
+                    qq(textEl).setText(text);
+                }
+            }
+        },
+
+        hideSpinner: function(id) {
+            qq(getFile(id)).removeClass(IN_PROGRESS_CLASS);
+            hide(getSpinner(id));
+        },
+
+        showSpinner: function(id) {
+            qq(getFile(id)).addClass(IN_PROGRESS_CLASS);
+            show(getSpinner(id));
+        },
+
+        generatePreview: function(id, optFileOrBlob) {
+            thumbGenerationQueue.push({id: id, optFileOrBlob: optFileOrBlob});
+            !thumbnailQueueMonitorRunning && generateNextQueuedPreview();
+        },
+
+        updateThumbnail: function(id, thumbnailUrl, showWaitingImg) {
+            thumbGenerationQueue.push({update: true, id: id, thumbnailUrl: thumbnailUrl, showWaitingImg: showWaitingImg});
+            !thumbnailQueueMonitorRunning && generateNextQueuedPreview();
+        },
+
+        hasDialog: function(type) {
+            return qq.supportedFeatures.dialogElement && !!getDialog(type);
+        },
+
+        showDialog: function(type, message, defaultValue) {
+            var dialog = getDialog(type),
+                messageEl = getTemplateEl(dialog, selectorClasses.dialogMessage),
+                inputEl = dialog.getElementsByTagName("INPUT")[0],
+                cancelBtn = getTemplateEl(dialog, selectorClasses.dialogCancelButton),
+                okBtn = getTemplateEl(dialog, selectorClasses.dialogOkButton),
+                promise = new qq.Promise(),
+
+                closeHandler = function() {
+                    cancelBtn.removeEventListener("click", cancelClickHandler);
+                    okBtn && okBtn.removeEventListener("click", okClickHandler);
+                    promise.failure();
+                },
+
+                cancelClickHandler = function() {
+                    cancelBtn.removeEventListener("click", cancelClickHandler);
+                    dialog.close();
+                },
+
+                okClickHandler = function() {
+                    dialog.removeEventListener("close", closeHandler);
+                    okBtn.removeEventListener("click", okClickHandler);
+                    dialog.close();
+
+                    promise.success(inputEl && inputEl.value);
+                };
+
+            dialog.addEventListener("close", closeHandler);
+            cancelBtn.addEventListener("click", cancelClickHandler);
+            okBtn && okBtn.addEventListener("click", okClickHandler);
+
+            if (inputEl) {
+                inputEl.value = defaultValue;
+            }
+            messageEl.textContent = message;
+
+            dialog.showModal();
+
+            return promise;
+        }
+    });
+};
+
+/*globals qq */
+qq.s3 = qq.s3 || {};
+
+qq.s3.util = qq.s3.util || (function() {
+    "use strict";
+
+    return {
+        AWS_PARAM_PREFIX: "x-amz-meta-",
+
+        SESSION_TOKEN_PARAM_NAME: "x-amz-security-token",
+
+        REDUCED_REDUNDANCY_PARAM_NAME: "x-amz-storage-class",
+        REDUCED_REDUNDANCY_PARAM_VALUE: "REDUCED_REDUNDANCY",
+
+        SERVER_SIDE_ENCRYPTION_PARAM_NAME: "x-amz-server-side-encryption",
+        SERVER_SIDE_ENCRYPTION_PARAM_VALUE: "AES256",
+
+        /**
+         * This allows for the region to be specified in the bucket's endpoint URL, or not.
+         *
+         * Examples of some valid endpoints are:
+         *     http://foo.s3.amazonaws.com
+         *     https://foo.s3.amazonaws.com
+         *     http://foo.s3-ap-northeast-1.amazonaws.com
+         *     foo.s3.amazonaws.com
+         *     http://foo.bar.com
+         *     http://s3.amazonaws.com/foo.bar.com
+         * ...etc
+         *
+         * @param endpoint The bucket's URL.
+         * @returns {String || undefined} The bucket name, or undefined if the URL cannot be parsed.
+         */
+        getBucket: function(endpoint) {
+            var patterns = [
+                    //bucket in domain
+                    /^(?:https?:\/\/)?([a-z0-9.\-_]+)\.s3(?:-[a-z0-9\-]+)?\.amazonaws\.com/i,
+                    //bucket in path
+                    /^(?:https?:\/\/)?s3(?:-[a-z0-9\-]+)?\.amazonaws\.com\/([a-z0-9.\-_]+)/i,
+                    //custom domain
+                    /^(?:https?:\/\/)?([a-z0-9.\-_]+)/i
+                ],
+                bucket;
+
+            qq.each(patterns, function(idx, pattern) {
+                var match = pattern.exec(endpoint);
+
+                if (match) {
+                    bucket = match[1];
+                    return false;
+                }
+            });
+
+            return bucket;
+        },
+
+        /**
+         * Create a policy document to be signed and sent along with the S3 upload request.
+         *
+         * @param spec Object with properties use to construct the policy document.
+         * @returns {Object} Policy doc.
+         */
+        getPolicy: function(spec) {
+            var policy = {},
+                conditions = [],
+                bucket = spec.bucket,
+                key = spec.key,
+                acl = spec.acl,
+                type = spec.type,
+                expirationDate = new Date(),
+                expectedStatus = spec.expectedStatus,
+                sessionToken = spec.sessionToken,
+                params = spec.params,
+                successRedirectUrl = qq.s3.util.getSuccessRedirectAbsoluteUrl(spec.successRedirectUrl),
+                minFileSize = spec.minFileSize,
+                maxFileSize = spec.maxFileSize,
+                reducedRedundancy = spec.reducedRedundancy,
+                serverSideEncryption = spec.serverSideEncryption;
+
+            policy.expiration = qq.s3.util.getPolicyExpirationDate(expirationDate);
+
+            conditions.push({acl: acl});
+            conditions.push({bucket: bucket});
+
+            if (type) {
+                conditions.push({"Content-Type": type});
+            }
+
+            // jscs:disable requireCamelCaseOrUpperCaseIdentifiers
+            if (expectedStatus) {
+                conditions.push({success_action_status: expectedStatus.toString()});
+            }
+
+            if (successRedirectUrl) {
+                conditions.push({success_action_redirect: successRedirectUrl});
+            }
+            // jscs:enable
+            if (reducedRedundancy) {
+                conditions.push({});
+                conditions[conditions.length - 1][qq.s3.util.REDUCED_REDUNDANCY_PARAM_NAME] = qq.s3.util.REDUCED_REDUNDANCY_PARAM_VALUE;
+            }
+
+            if (sessionToken) {
+                conditions.push({});
+                conditions[conditions.length - 1][qq.s3.util.SESSION_TOKEN_PARAM_NAME] = sessionToken;
+            }
+
+            if (serverSideEncryption) {
+                conditions.push({});
+                conditions[conditions.length - 1][qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_NAME] = qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_VALUE;
+            }
+
+            conditions.push({key: key});
+
+            // user metadata
+            qq.each(params, function(name, val) {
+                var awsParamName = qq.s3.util.AWS_PARAM_PREFIX + name,
+                    param = {};
+
+                param[awsParamName] = encodeURIComponent(val);
+                conditions.push(param);
+            });
+
+            policy.conditions = conditions;
+
+            qq.s3.util.enforceSizeLimits(policy, minFileSize, maxFileSize);
+
+            return policy;
+        },
+
+        /**
+         * Update a previously constructed policy document with updated credentials.  Currently, this only requires we
+         * update the session token.  This is only relevant if requests are being signed client-side.
+         *
+         * @param policy Live policy document
+         * @param newSessionToken Updated session token.
+         */
+        refreshPolicyCredentials: function(policy, newSessionToken) {
+            var sessionTokenFound = false;
+
+            qq.each(policy.conditions, function(oldCondIdx, oldCondObj) {
+                qq.each(oldCondObj, function(oldCondName, oldCondVal) {
+                    if (oldCondName === qq.s3.util.SESSION_TOKEN_PARAM_NAME) {
+                        oldCondObj[oldCondName] = newSessionToken;
+                        sessionTokenFound = true;
+                    }
+                });
+            });
+
+            if (!sessionTokenFound) {
+                policy.conditions.push({});
+                policy.conditions[policy.conditions.length - 1][qq.s3.util.SESSION_TOKEN_PARAM_NAME] = newSessionToken;
+            }
+        },
+
+        /**
+         * Generates all parameters to be passed along with the S3 upload request.  This includes invoking a callback
+         * that is expected to asynchronously retrieve a signature for the policy document.  Note that the server
+         * signing the request should reject a "tainted" policy document that includes unexpected values, since it is
+         * still possible for a malicious user to tamper with these values during policy document generation, b
+         * before it is sent to the server for signing.
+         *
+         * @param spec Object with properties: `params`, `type`, `key`, `accessKey`, `acl`, `expectedStatus`, `successRedirectUrl`,
+         * `reducedRedundancy`, serverSideEncryption, and `log()`, along with any options associated with `qq.s3.util.getPolicy()`.
+         * @returns {qq.Promise} Promise that will be fulfilled once all parameters have been determined.
+         */
+        generateAwsParams: function(spec, signPolicyCallback) {
+            var awsParams = {},
+                customParams = spec.params,
+                promise = new qq.Promise(),
+                policyJson = qq.s3.util.getPolicy(spec),
+                sessionToken = spec.sessionToken,
+                type = spec.type,
+                key = spec.key,
+                accessKey = spec.accessKey,
+                acl = spec.acl,
+                expectedStatus = spec.expectedStatus,
+                successRedirectUrl = qq.s3.util.getSuccessRedirectAbsoluteUrl(spec.successRedirectUrl),
+                reducedRedundancy = spec.reducedRedundancy,
+                serverSideEncryption = spec.serverSideEncryption,
+                log = spec.log;
+
+            awsParams.key = key;
+            awsParams.AWSAccessKeyId = accessKey;
+
+            if (type) {
+                awsParams["Content-Type"] = type;
+            }
+            // jscs:disable requireCamelCaseOrUpperCaseIdentifiers
+            if (expectedStatus) {
+                awsParams.success_action_status = expectedStatus;
+            }
+
+            if (successRedirectUrl) {
+                awsParams.success_action_redirect = successRedirectUrl;
+            }
+            // jscs:enable
+            if (reducedRedundancy) {
+                awsParams[qq.s3.util.REDUCED_REDUNDANCY_PARAM_NAME] = qq.s3.util.REDUCED_REDUNDANCY_PARAM_VALUE;
+            }
+
+            if (serverSideEncryption) {
+                awsParams[qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_NAME] = qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_VALUE;
+            }
+
+            if (sessionToken) {
+                awsParams[qq.s3.util.SESSION_TOKEN_PARAM_NAME] = sessionToken;
+            }
+
+            awsParams.acl = acl;
+
+            // Custom (user-supplied) params must be prefixed with the value of `qq.s3.util.AWS_PARAM_PREFIX`.
+            // Custom param values will be URI encoded as well.
+            qq.each(customParams, function(name, val) {
+                var awsParamName = qq.s3.util.AWS_PARAM_PREFIX + name;
+                awsParams[awsParamName] = encodeURIComponent(val);
+            });
+
+            // Invoke a promissory callback that should provide us with a base64-encoded policy doc and an
+            // HMAC signature for the policy doc.
+            signPolicyCallback(policyJson).then(
+                function(policyAndSignature, updatedAccessKey, updatedSessionToken) {
+                    awsParams.policy = policyAndSignature.policy;
+                    awsParams.signature = policyAndSignature.signature;
+
+                    if (updatedAccessKey) {
+                        awsParams.AWSAccessKeyId = updatedAccessKey;
+                    }
+                    if (updatedSessionToken) {
+                        awsParams[qq.s3.util.SESSION_TOKEN_PARAM_NAME] = updatedSessionToken;
+                    }
+
+                    promise.success(awsParams);
+                },
+                function(errorMessage) {
+                    errorMessage = errorMessage || "Can't continue further with request to S3 as we did not receive " +
+                                                   "a valid signature and policy from the server.";
+
+                    log("Policy signing failed.  " + errorMessage, "error");
+                    promise.failure(errorMessage);
+                }
+            );
+
+            return promise;
+        },
+
+        /**
+         * Add a condition to an existing S3 upload request policy document used to ensure AWS enforces any size
+         * restrictions placed on files server-side.  This is important to do, in case users mess with the client-side
+         * checks already in place.
+         *
+         * @param policy Policy document as an `Object`, with a `conditions` property already attached
+         * @param minSize Minimum acceptable size, in bytes
+         * @param maxSize Maximum acceptable size, in bytes (0 = unlimited)
+         */
+        enforceSizeLimits: function(policy, minSize, maxSize) {
+            var adjustedMinSize = minSize < 0 ? 0 : minSize,
+                // Adjust a maxSize of 0 to the largest possible integer, since we must specify a high and a low in the request
+                adjustedMaxSize = maxSize <= 0 ? 9007199254740992 : maxSize;
+
+            if (minSize > 0 || maxSize > 0) {
+                policy.conditions.push(["content-length-range", adjustedMinSize.toString(), adjustedMaxSize.toString()]);
+            }
+        },
+
+        getPolicyExpirationDate: function(date) {
+            /*jshint -W014 */
+            // Is this going to be a problem if we encounter this moments before 2 AM just before daylight savings time ends?
+            date.setMinutes(date.getMinutes() + 5);
+
+            if (Date.prototype.toISOString) {
+                return date.toISOString();
+            }
+            else {
+                var pad = function(number) {
+                    var r = String(number);
+
+                    if (r.length === 1) {
+                        r = "0" + r;
+                    }
+
+                    return r;
+                };
+
+                return date.getUTCFullYear()
+                        + "-" + pad(date.getUTCMonth() + 1)
+                        + "-" + pad(date.getUTCDate())
+                        + "T" + pad(date.getUTCHours())
+                        + ":" + pad(date.getUTCMinutes())
+                        + ":" + pad(date.getUTCSeconds())
+                        + "." + String((date.getUTCMilliseconds() / 1000).toFixed(3)).slice(2, 5)
+                        + "Z";
+            }
+        },
+
+        /**
+         * Looks at a response from S3 contained in an iframe and parses the query string in an attempt to identify
+         * the associated resource.
+         *
+         * @param iframe Iframe containing response
+         * @returns {{bucket: *, key: *, etag: *}}
+         */
+        parseIframeResponse: function(iframe) {
+            var doc = iframe.contentDocument || iframe.contentWindow.document,
+                queryString = doc.location.search,
+                match = /bucket=(.+)&key=(.+)&etag=(.+)/.exec(queryString);
+
+            if (match) {
+                return {
+                    bucket: match[1],
+                    key: match[2],
+                    etag: match[3].replace(/%22/g, "")
+                };
+            }
+        },
+
+        /**
+         * @param successRedirectUrl Relative or absolute location of success redirect page
+         * @returns {*|string} undefined if the parameter is undefined, otherwise the absolute location of the success redirect page
+         */
+        getSuccessRedirectAbsoluteUrl: function(successRedirectUrl) {
+            if (successRedirectUrl) {
+                var targetAnchorContainer = document.createElement("div"),
+                    targetAnchor;
+
+                if (qq.ie7()) {
+                    // Note that we must make use of `innerHTML` for IE7 only instead of simply creating an anchor via
+                    // `document.createElement('a')` and setting the `href` attribute.  The latter approach does not allow us to
+                    // obtain an absolute URL in IE7 if the `endpoint` is a relative URL.
+                    targetAnchorContainer.innerHTML = "<a href='" + successRedirectUrl + "'></a>";
+                    targetAnchor = targetAnchorContainer.firstChild;
+                    return targetAnchor.href;
+                }
+                else {
+                    // IE8 and IE9 do not seem to derive an absolute URL from a relative URL using the `innerHTML`
+                    // approach above, so we'll just create an anchor this way and set it's `href` attribute.
+                    // Due to yet another quirk in IE8 and IE9, we have to set the `href` equal to itself
+                    // in order to ensure relative URLs will be properly parsed.
+                    targetAnchor = document.createElement("a");
+                    targetAnchor.href = successRedirectUrl;
+                    targetAnchor.href = targetAnchor.href;
+                    return targetAnchor.href;
+                }
+            }
+        },
+
+        // AWS employs a strict interpretation of [RFC 3986](http://tools.ietf.org/html/rfc3986#page-12).
+        // So, we must ensure all reserved characters listed in the spec are percent-encoded,
+        // and spaces are replaced with "+".
+        encodeQueryStringParam: function(param) {
+            var percentEncoded = encodeURIComponent(param);
+
+            // %-encode characters not handled by `encodeURIComponent` (to follow RFC 3986)
+            percentEncoded = percentEncoded.replace(/[!'()]/g, escape);
+
+            // %-encode characters not handled by `escape` (to follow RFC 3986)
+            percentEncoded = percentEncoded.replace(/\*/g, "%2A");
+
+            // replace percent-encoded spaces with a "+"
+            return percentEncoded.replace(/%20/g, "+");
+        }
+    };
+}());
+
+/*globals qq*/
+/**
+ * Defines the public API for non-traditional FineUploaderBasic mode.
+ */
+(function() {
+    "use strict";
+
+    qq.nonTraditionalBasePublicApi = {
+        setUploadSuccessParams: function(params, id) {
+            this._uploadSuccessParamsStore.set(params, id);
+        },
+        setUploadSuccessEndpoint: function(endpoint, id) {
+            this._uploadSuccessEndpointStore.set(endpoint, id);
+        }
+    };
+
+    qq.nonTraditionalBasePrivateApi = {
+        /**
+         * When the upload has completed, if it is successful, send a request to the `successEndpoint` (if defined).
+         * This will hold up the call to the `onComplete` callback until we have determined success of the upload
+         * according to the local server, if a `successEndpoint` has been defined by the integrator.
+         *
+         * @param id ID of the completed upload
+         * @param name Name of the associated item
+         * @param result Object created from the server's parsed JSON response.
+         * @param xhr Associated XmlHttpRequest, if this was used to send the request.
+         * @returns {boolean || qq.Promise} true/false if success can be determined immediately, otherwise a `qq.Promise`
+         * if we need to ask the server.
+         * @private
+         */
+        _onComplete: function(id, name, result, xhr) {
+            var success = result.success ? true : false,
+                self = this,
+                onCompleteArgs = arguments,
+                successEndpoint = this._uploadSuccessEndpointStore.get(id),
+                successCustomHeaders = this._options.uploadSuccess.customHeaders,
+                successMethod = this._options.uploadSuccess.method,
+                cors = this._options.cors,
+                promise = new qq.Promise(),
+                uploadSuccessParams = this._uploadSuccessParamsStore.get(id),
+                fileParams = this._paramsStore.get(id),
+
+                // If we are waiting for confirmation from the local server, and have received it,
+                // include properties from the local server response in the `response` parameter
+                // sent to the `onComplete` callback, delegate to the parent `_onComplete`, and
+                // fulfill the associated promise.
+                onSuccessFromServer = function(successRequestResult) {
+                    delete self._failedSuccessRequestCallbacks[id];
+                    qq.extend(result, successRequestResult);
+                    qq.FineUploaderBasic.prototype._onComplete.apply(self, onCompleteArgs);
+                    promise.success(successRequestResult);
+                },
+
+                // If the upload success request fails, attempt to re-send the success request (via the core retry code).
+                // The entire upload may be restarted if the server returns a "reset" property with a value of true as well.
+                onFailureFromServer = function(successRequestResult) {
+                    var callback = submitSuccessRequest;
+
+                    qq.extend(result, successRequestResult);
+
+                    if (result && result.reset) {
+                        callback = null;
+                    }
+
+                    if (!callback) {
+                        delete self._failedSuccessRequestCallbacks[id];
+                    }
+                    else {
+                        self._failedSuccessRequestCallbacks[id] = callback;
+                    }
+
+                    if (!self._onAutoRetry(id, name, result, xhr, callback)) {
+                        qq.FineUploaderBasic.prototype._onComplete.apply(self, onCompleteArgs);
+                        promise.failure(successRequestResult);
+                    }
+                },
+                submitSuccessRequest,
+                successAjaxRequester;
+
+            // Ask the local server if the file sent is ok.
+            if (success && successEndpoint) {
+                successAjaxRequester = new qq.UploadSuccessAjaxRequester({
+                    endpoint: successEndpoint,
+                    method: successMethod,
+                    customHeaders: successCustomHeaders,
+                    cors: cors,
+                    log: qq.bind(this.log, this)
+                });
+
+                // combine custom params and default params
+                qq.extend(uploadSuccessParams, self._getEndpointSpecificParams(id, result, xhr), true);
+
+                // include any params associated with the file
+                fileParams && qq.extend(uploadSuccessParams, fileParams, true);
+
+                submitSuccessRequest = qq.bind(function() {
+                    successAjaxRequester.sendSuccessRequest(id, uploadSuccessParams)
+                        .then(onSuccessFromServer, onFailureFromServer);
+                }, self);
+
+                submitSuccessRequest();
+
+                return promise;
+            }
+
+            // If we are not asking the local server about the file, just delegate to the parent `_onComplete`.
+            return qq.FineUploaderBasic.prototype._onComplete.apply(this, arguments);
+        },
+
+        // If the failure occurred on an upload success request (and a reset was not ordered), try to resend that instead.
+        _manualRetry: function(id) {
+            var successRequestCallback = this._failedSuccessRequestCallbacks[id];
+
+            return qq.FineUploaderBasic.prototype._manualRetry.call(this, id, successRequestCallback);
+        }
+    };
+}());
+
+/*globals qq */
+/**
+ * This defines FineUploaderBasic mode w/ support for uploading to S3, which provides all the basic
+ * functionality of Fine Uploader Basic as well as code to handle uploads directly to S3.
+ * Some inherited options and API methods have a special meaning in the context of the S3 uploader.
+ */
+(function() {
+    "use strict";
+
+    qq.s3.FineUploaderBasic = function(o) {
+        var options = {
+            request: {
+                // public key (required for server-side signing, ignored if `credentials` have been provided)
+                accessKey: null
+            },
+
+            objectProperties: {
+                acl: "private",
+
+                // string or a function which may be promissory
+                bucket: qq.bind(function(id) {
+                    return qq.s3.util.getBucket(this.getEndpoint(id));
+                }, this),
+
+                // 'uuid', 'filename', or a function which may be promissory
+                key: "uuid",
+
+                reducedRedundancy: false,
+
+                serverSideEncryption: false
+            },
+
+            credentials: {
+                // Public key (required).
+                accessKey: null,
+                // Private key (required).
+                secretKey: null,
+                // Expiration date for the credentials (required).  May be an ISO string or a `Date`.
+                expiration: null,
+                // Temporary credentials session token.
+                // Only required for temporary credentials obtained via AssumeRoleWithWebIdentity.
+                sessionToken: null
+            },
+
+            // optional/ignored if `credentials` is provided
+            signature: {
+                endpoint: null,
+                customHeaders: {}
+            },
+
+            uploadSuccess: {
+                endpoint: null,
+
+                method: "POST",
+
+                // In addition to the default params sent by Fine Uploader
+                params: {},
+
+                customHeaders: {}
+            },
+
+            // required if non-File-API browsers, such as IE9 and older, are used
+            iframeSupport: {
+                localBlankPagePath: null
+            },
+
+            chunking: {
+                // minimum part size is 5 MiB when uploading to S3
+                partSize: 5242880
+            },
+
+            cors: {
+                allowXdr: true
+            },
+
+            callbacks: {
+                onCredentialsExpired: function() {}
+            }
+        };
+
+        // Replace any default options with user defined ones
+        qq.extend(options, o, true);
+
+        if (!this.setCredentials(options.credentials, true)) {
+            this._currentCredentials.accessKey = options.request.accessKey;
+        }
+
+        this._aclStore = this._createStore(options.objectProperties.acl);
+
+        // Call base module
+        qq.FineUploaderBasic.call(this, options);
+
+        this._uploadSuccessParamsStore = this._createStore(this._options.uploadSuccess.params);
+        this._uploadSuccessEndpointStore = this._createStore(this._options.uploadSuccess.endpoint);
+
+        // This will hold callbacks for failed uploadSuccess requests that will be invoked on retry.
+        // Indexed by file ID.
+        this._failedSuccessRequestCallbacks = {};
+
+        // Holds S3 keys for file representations constructed from a session request.
+        this._cannedKeys = {};
+        // Holds S3 buckets for file representations constructed from a session request.
+        this._cannedBuckets = {};
+
+        this._buckets = {};
+    };
+
+    // Inherit basic public & private API methods.
+    qq.extend(qq.s3.FineUploaderBasic.prototype, qq.basePublicApi);
+    qq.extend(qq.s3.FineUploaderBasic.prototype, qq.basePrivateApi);
+    qq.extend(qq.s3.FineUploaderBasic.prototype, qq.nonTraditionalBasePublicApi);
+    qq.extend(qq.s3.FineUploaderBasic.prototype, qq.nonTraditionalBasePrivateApi);
+
+    // Define public & private API methods for this module.
+    qq.extend(qq.s3.FineUploaderBasic.prototype, {
+        getBucket: function(id) {
+            if (this._cannedBuckets[id] == null) {
+                return this._buckets[id];
+            }
+            return this._cannedBuckets[id];
+        },
+
+        /**
+         * @param id File ID
+         * @returns {*} Key name associated w/ the file, if one exists
+         */
+        getKey: function(id) {
+            /* jshint eqnull:true */
+            if (this._cannedKeys[id] == null) {
+                return this._handler.getThirdPartyFileId(id);
+            }
+
+            return this._cannedKeys[id];
+        },
+
+        /**
+         * Override the parent's reset function to cleanup various S3-related items.
+         */
+        reset: function() {
+            qq.FineUploaderBasic.prototype.reset.call(this);
+            this._failedSuccessRequestCallbacks = [];
+            this._buckets = {};
+        },
+
+        setCredentials: function(credentials, ignoreEmpty) {
+            if (credentials && credentials.secretKey) {
+                if (!credentials.accessKey) {
+                    throw new qq.Error("Invalid credentials: no accessKey");
+                }
+                else if (!credentials.expiration) {
+                    throw new qq.Error("Invalid credentials: no expiration");
+                }
+                else {
+                    this._currentCredentials = qq.extend({}, credentials);
+
+                    // Ensure expiration is a `Date`.  If initially a string, assuming it is in ISO format.
+                    if (qq.isString(credentials.expiration)) {
+                        this._currentCredentials.expiration = new Date(credentials.expiration);
+                    }
+                }
+
+                return true;
+            }
+            else if (!ignoreEmpty) {
+                throw new qq.Error("Invalid credentials parameter!");
+            }
+            else {
+                this._currentCredentials = {};
+            }
+        },
+
+        setAcl: function(acl, id) {
+            this._aclStore.set(acl, id);
+        },
+
+        /**
+         * Ensures the parent's upload handler creator passes any additional S3-specific options to the handler as well
+         * as information required to instantiate the specific handler based on the current browser's capabilities.
+         *
+         * @returns {qq.UploadHandlerController}
+         * @private
+         */
+        _createUploadHandler: function() {
+            var self = this,
+                additionalOptions = {
+                    aclStore: this._aclStore,
+                    getBucket: qq.bind(this._determineBucket, this),
+                    getKeyName: qq.bind(this._determineKeyName, this),
+                    iframeSupport: this._options.iframeSupport,
+                    objectProperties: this._options.objectProperties,
+                    signature: this._options.signature,
+                    // pass size limit validation values to include in the request so AWS enforces this server-side
+                    validation: {
+                        minSizeLimit: this._options.validation.minSizeLimit,
+                        maxSizeLimit: this._options.validation.sizeLimit
+                    }
+                };
+
+            // We assume HTTP if it is missing from the start of the endpoint string.
+            qq.override(this._endpointStore, function(super_) {
+                return {
+                    get: function(id) {
+                        var endpoint = super_.get(id);
+
+                        if (endpoint.indexOf("http") < 0) {
+                            return "http://" + endpoint;
+                        }
+
+                        return endpoint;
+                    }
+                };
+            });
+
+            // Param names should be lower case to avoid signature mismatches
+            qq.override(this._paramsStore, function(super_) {
+                return {
+                    get: function(id) {
+                        var oldParams = super_.get(id),
+                            modifiedParams = {};
+
+                        qq.each(oldParams, function(name, val) {
+                            modifiedParams[name.toLowerCase()] = qq.isFunction(val) ? val() : val;
+                        });
+
+                        return modifiedParams;
+                    }
+                };
+            });
+
+            additionalOptions.signature.credentialsProvider = {
+                get: function() {
+                    return self._currentCredentials;
+                },
+
+                onExpired: function() {
+                    var updateCredentials = new qq.Promise(),
+                        callbackRetVal = self._options.callbacks.onCredentialsExpired();
+
+                    if (qq.isGenericPromise(callbackRetVal)) {
+                        callbackRetVal.then(function(credentials) {
+                            try {
+                                self.setCredentials(credentials);
+                                updateCredentials.success();
+                            }
+                            catch (error) {
+                                self.log("Invalid credentials returned from onCredentialsExpired callback! (" + error.message + ")", "error");
+                                updateCredentials.failure("onCredentialsExpired did not return valid credentials.");
+                            }
+                        }, function(errorMsg) {
+                            self.log("onCredentialsExpired callback indicated failure! (" + errorMsg + ")", "error");
+                            updateCredentials.failure("onCredentialsExpired callback failed.");
+                        });
+                    }
+                    else {
+                        self.log("onCredentialsExpired callback did not return a promise!", "error");
+                        updateCredentials.failure("Unexpected return value for onCredentialsExpired.");
+                    }
+
+                    return updateCredentials;
+                }
+            };
+
+            return qq.FineUploaderBasic.prototype._createUploadHandler.call(this, additionalOptions, "s3");
+        },
+
+        _determineBucket: function(id) {
+            var maybeBucket = this._options.objectProperties.bucket,
+                promise = new qq.Promise(),
+                self = this;
+
+            if (qq.isFunction(maybeBucket)) {
+                maybeBucket = maybeBucket(id);
+                if (qq.isGenericPromise(maybeBucket)) {
+                    promise = maybeBucket;
+                }
+                else {
+                    promise.success(maybeBucket);
+                }
+            }
+            else if (qq.isString(maybeBucket)) {
+                promise.success(maybeBucket);
+            }
+
+            promise.then(
+                function success(bucket) {
+                    self._buckets[id] = bucket;
+                },
+
+                function failure(errorMsg) {
+                    qq.log("Problem determining bucket for ID " + id + " (" + errorMsg + ")", "error");
+                }
+            );
+
+            return promise;
+        },
+
+        /**
+         * Determine the file's key name and passes it to the caller via a promissory callback.  This also may
+         * delegate to an integrator-defined function that determines the file's key name on demand,
+         * which also may be promissory.
+         *
+         * @param id ID of the file
+         * @param filename Name of the file
+         * @returns {qq.Promise} A promise that will be fulfilled when the key name has been determined (and will be passed to the caller via the success callback).
+         * @private
+         */
+        _determineKeyName: function(id, filename) {
+            /*jshint -W015*/
+            var promise = new qq.Promise(),
+                keynameLogic = this._options.objectProperties.key,
+                extension = qq.getExtension(filename),
+                onGetKeynameFailure = promise.failure,
+                onGetKeynameSuccess = function(keyname, extension) {
+                    var keynameToUse = keyname;
+
+                    if (extension !== undefined) {
+                        keynameToUse += "." + extension;
+                    }
+
+                    promise.success(keynameToUse);
+                };
+
+            switch (keynameLogic) {
+                case "uuid":
+                    onGetKeynameSuccess(this.getUuid(id), extension);
+                    break;
+                case "filename":
+                    onGetKeynameSuccess(filename);
+                    break;
+                default:
+                    if (qq.isFunction(keynameLogic)) {
+                        this._handleKeynameFunction(keynameLogic, id, onGetKeynameSuccess, onGetKeynameFailure);
+                    }
+                    else {
+                        this.log(keynameLogic + " is not a valid value for the s3.keyname option!", "error");
+                        onGetKeynameFailure();
+                    }
+            }
+
+            return promise;
+        },
+
+        /**
+         * Called by the internal onUpload handler if the integrator has supplied a function to determine
+         * the file's key name.  The integrator's function may be promissory.  We also need to fulfill
+         * the promise contract associated with the caller as well.
+         *
+         * @param keynameFunc Integrator-supplied function that must be executed to determine the key name.  May be promissory.
+         * @param id ID of the associated file
+         * @param successCallback Invoke this if key name retrieval is successful, passing in the key name.
+         * @param failureCallback Invoke this if key name retrieval was unsuccessful.
+         * @private
+         */
+        _handleKeynameFunction: function(keynameFunc, id, successCallback, failureCallback) {
+            var self = this,
+                onSuccess = function(keyname) {
+                    successCallback(keyname);
+                },
+                onFailure = function(reason) {
+                    self.log(qq.format("Failed to retrieve key name for {}.  Reason: {}", id, reason || "null"), "error");
+                    failureCallback(reason);
+                },
+                keyname = keynameFunc.call(this, id);
+
+            if (qq.isGenericPromise(keyname)) {
+                keyname.then(onSuccess, onFailure);
+            }
+            /*jshint -W116*/
+            else if (keyname == null) {
+                onFailure();
+            }
+            else {
+                onSuccess(keyname);
+            }
+        },
+
+        _getEndpointSpecificParams: function(id, response, maybeXhr) {
+            var params = {
+                key: this.getKey(id),
+                uuid: this.getUuid(id),
+                name: this.getName(id),
+                bucket: this.getBucket(id)
+            };
+
+            if (maybeXhr && maybeXhr.getResponseHeader("ETag")) {
+                params.etag = maybeXhr.getResponseHeader("ETag");
+            }
+            else if (response.etag) {
+                params.etag = response.etag;
+            }
+
+            return params;
+        },
+
+        // Hooks into the base internal `_onSubmitDelete` to add key and bucket params to the delete file request.
+        _onSubmitDelete: function(id, onSuccessCallback) {
+            var additionalMandatedParams = {
+                key: this.getKey(id),
+                bucket: this.getBucket(id)
+            };
+
+            return qq.FineUploaderBasic.prototype._onSubmitDelete.call(this, id, onSuccessCallback, additionalMandatedParams);
+        },
+
+        _addCannedFile: function(sessionData) {
+            var id;
+
+            /* jshint eqnull:true */
+            if (sessionData.s3Key == null) {
+                throw new qq.Error("Did not find s3Key property in server session response.  This is required!");
+            }
+            else {
+                id = qq.FineUploaderBasic.prototype._addCannedFile.apply(this, arguments);
+                this._cannedKeys[id] = sessionData.s3Key;
+                this._cannedBuckets[id] = sessionData.s3Bucket;
+            }
+
+            return id;
+        }
+    });
+}());
+
+/* globals qq, CryptoJS */
+/**
+ * Handles signature determination for HTML Form Upload requests and Multipart Uploader requests (via the S3 REST API).
+ *
+ * If the S3 requests are to be signed server side, this module will send a POST request to the server in an attempt
+ * to solicit signatures for various S3-related requests.  This module also parses the response and attempts
+ * to determine if the effort was successful.
+ *
+ * If the S3 requests are to be signed client-side, without the help of a server, this module will utilize CryptoJS to
+ * sign the requests directly in the browser and send them off to S3.
+ *
+ * @param o Options associated with all such requests
+ * @returns {{getSignature: Function}} API method used to initiate the signature request.
+ * @constructor
+ */
+qq.s3.RequestSigner = function(o) {
+    "use strict";
+
+    var requester,
+        thisSignatureRequester = this,
+        pendingSignatures = {},
+        options = {
+            expectingPolicy: false,
+            method: "POST",
+            signatureSpec: {
+                credentialsProvider: {},
+                endpoint: null,
+                customHeaders: {}
+            },
+            maxConnections: 3,
+            paramsStore: {},
+            cors: {
+                expected: false,
+                sendCredentials: false
+            },
+            log: function(str, level) {}
+        },
+        credentialsProvider;
+
+    qq.extend(options, o, true);
+    credentialsProvider = options.signatureSpec.credentialsProvider;
+
+    function handleSignatureReceived(id, xhrOrXdr, isError) {
+        var responseJson = xhrOrXdr.responseText,
+            pendingSignatureData = pendingSignatures[id],
+            promise = pendingSignatureData.promise,
+            errorMessage, response;
+
+        delete pendingSignatures[id];
+
+        // Attempt to parse what we would expect to be a JSON response
+        if (responseJson) {
+            try {
+                response = qq.parseJson(responseJson);
+            }
+            catch (error) {
+                options.log("Error attempting to parse signature response: " + error, "error");
+            }
+        }
+
+        // If we have received a parsable response, and it has an `invalid` property,
+        // the policy document or request headers may have been tampered with client-side.
+        if (response && response.invalid) {
+            isError = true;
+            errorMessage = "Invalid policy document or request headers!";
+        }
+        // Make sure the response contains policy & signature properties
+        else if (response) {
+            if (options.expectingPolicy && !response.policy) {
+                isError = true;
+                errorMessage = "Response does not include the base64 encoded policy!";
+            }
+            else if (!response.signature) {
+                isError = true;
+                errorMessage = "Response does not include the signature!";
+            }
+        }
+        // Something unknown went wrong
+        else {
+            isError = true;
+            errorMessage = "Received an empty or invalid response from the server!";
+        }
+
+        if (isError) {
+            if (errorMessage) {
+                options.log(errorMessage, "error");
+            }
+
+            promise.failure(errorMessage);
+        }
+        else {
+            promise.success(response);
+        }
+    }
+
+    function getToSignAndEndOfUrl(type, bucket, key, contentType, headers, uploadId, partNum) {
+        var method = "POST",
+            headerNames = [],
+            headersAsString = "",
+            endOfUrl;
+
+        /*jshint indent:false */
+        switch (type) {
+            case thisSignatureRequester.REQUEST_TYPE.MULTIPART_ABORT:
+                method = "DELETE";
+                endOfUrl = qq.format("uploadId={}", uploadId);
+                break;
+            case thisSignatureRequester.REQUEST_TYPE.MULTIPART_INITIATE:
+                endOfUrl = "uploads";
+                break;
+            case thisSignatureRequester.REQUEST_TYPE.MULTIPART_COMPLETE:
+                endOfUrl = qq.format("uploadId={}", uploadId);
+                break;
+            case thisSignatureRequester.REQUEST_TYPE.MULTIPART_UPLOAD:
+                method = "PUT";
+                endOfUrl = qq.format("partNumber={}&uploadId={}", partNum, uploadId);
+                break;
+        }
+
+        endOfUrl = key + "?" + endOfUrl;
+
+        qq.each(headers, function(name) {
+            headerNames.push(name);
+        });
+        headerNames.sort();
+
+        qq.each(headerNames, function(idx, name) {
+            headersAsString += name + ":" + headers[name] + "\n";
+        });
+
+        return {
+            toSign: qq.format("{}\n\n{}\n\n{}/{}/{}",
+                        method, contentType || "", headersAsString || "\n", bucket, endOfUrl),
+            endOfUrl: endOfUrl
+        };
+    }
+
+    function determineSignatureClientSide(toBeSigned, signatureEffort, updatedAccessKey, updatedSessionToken) {
+        var updatedHeaders;
+
+        // REST API request
+        if (toBeSigned.signatureConstructor) {
+            if (updatedSessionToken) {
+                updatedHeaders = toBeSigned.signatureConstructor.getHeaders();
+                updatedHeaders[qq.s3.util.SESSION_TOKEN_PARAM_NAME] = updatedSessionToken;
+                toBeSigned.signatureConstructor.withHeaders(updatedHeaders);
+            }
+
+            signApiRequest(toBeSigned.signatureConstructor.getToSign().stringToSign, signatureEffort);
+        }
+        // Form upload (w/ policy document)
+        else {
+            updatedSessionToken && qq.s3.util.refreshPolicyCredentials(toBeSigned, updatedSessionToken);
+            signPolicy(toBeSigned, signatureEffort, updatedAccessKey, updatedSessionToken);
+        }
+    }
+
+    function signPolicy(policy, signatureEffort, updatedAccessKey, updatedSessionToken) {
+        var policyStr = JSON.stringify(policy),
+            policyWordArray = CryptoJS.enc.Utf8.parse(policyStr),
+            base64Policy = CryptoJS.enc.Base64.stringify(policyWordArray),
+            policyHmacSha1 = CryptoJS.HmacSHA1(base64Policy, credentialsProvider.get().secretKey),
+            policyHmacSha1Base64 = CryptoJS.enc.Base64.stringify(policyHmacSha1);
+
+        signatureEffort.success({
+            policy: base64Policy,
+            signature: policyHmacSha1Base64
+        }, updatedAccessKey, updatedSessionToken);
+    }
+
+    function signApiRequest(headersStr, signatureEffort) {
+        var headersWordArray = CryptoJS.enc.Utf8.parse(headersStr),
+            headersHmacSha1 = CryptoJS.HmacSHA1(headersWordArray, credentialsProvider.get().secretKey),
+            headersHmacSha1Base64 = CryptoJS.enc.Base64.stringify(headersHmacSha1);
+
+        signatureEffort.success({signature: headersHmacSha1Base64});
+    }
+
+    requester = qq.extend(this, new qq.AjaxRequester({
+        acceptHeader: "application/json",
+        method: options.method,
+        contentType: "application/json; charset=utf-8",
+        endpointStore: {
+            get: function() {
+                return options.signatureSpec.endpoint;
+            }
+        },
+        paramsStore: options.paramsStore,
+        maxConnections: options.maxConnections,
+        customHeaders: options.signatureSpec.customHeaders,
+        log: options.log,
+        onComplete: handleSignatureReceived,
+        cors: options.cors
+    }));
+
+    qq.extend(this, {
+        /**
+         * On success, an object containing the parsed JSON response will be passed into the success handler if the
+         * request succeeds.  Otherwise an error message will be passed into the failure method.
+         *
+         * @param id File ID.
+         * @param toBeSigned an Object that holds the item(s) to be signed
+         * @returns {qq.Promise} A promise that is fulfilled when the response has been received.
+         */
+        getSignature: function(id, toBeSigned) {
+            var params = toBeSigned,
+                signatureEffort = new qq.Promise();
+
+            if (credentialsProvider.get().secretKey && window.CryptoJS) {
+                if (credentialsProvider.get().expiration.getTime() > Date.now()) {
+                    determineSignatureClientSide(toBeSigned, signatureEffort);
+                }
+                // If credentials are expired, ask for new ones before attempting to sign request
+                else {
+                    credentialsProvider.onExpired().then(function() {
+                        determineSignatureClientSide(toBeSigned,
+                            signatureEffort,
+                            credentialsProvider.get().accessKey,
+                            credentialsProvider.get().sessionToken);
+                    }, function(errorMsg) {
+                        options.log("Attempt to update expired credentials apparently failed! Unable to sign request.  ", "error");
+                        signatureEffort.failure("Unable to sign request - expired credentials.");
+                    });
+                }
+            }
+            else {
+                options.log("Submitting S3 signature request for " + id);
+
+                if (params.signatureConstructor) {
+                    params = {headers: params.signatureConstructor.getToSign().stringToSign};
+                }
+
+                requester.initTransport(id)
+                    .withParams(params)
+                    .send();
+
+                pendingSignatures[id] = {
+                    promise: signatureEffort
+                };
+            }
+
+            return signatureEffort;
+        },
+
+        constructStringToSign: function(type, bucket, key) {
+            var headers = {},
+                uploadId, contentType, partNum, toSignAndEndOfUrl;
+
+            return {
+                withHeaders: function(theHeaders) {
+                    headers = theHeaders;
+                    return this;
+                },
+
+                withUploadId: function(theUploadId) {
+                    uploadId = theUploadId;
+                    return this;
+                },
+
+                withContentType: function(theContentType) {
+                    contentType = theContentType;
+                    return this;
+                },
+
+                withPartNum: function(thePartNum) {
+                    partNum = thePartNum;
+                    return this;
+                },
+
+                getToSign: function() {
+                    var sessionToken = credentialsProvider.get().sessionToken;
+
+                    headers["x-amz-date"] = new Date().toUTCString();
+
+                    if (sessionToken) {
+                        headers[qq.s3.util.SESSION_TOKEN_PARAM_NAME] = sessionToken;
+                    }
+
+                    toSignAndEndOfUrl = getToSignAndEndOfUrl(type, bucket, key, contentType, headers, uploadId, partNum);
+
+                    return {
+                        headers: (function() {
+                            if (contentType) {
+                                headers["Content-Type"] = contentType;
+                            }
+
+                            return headers;
+                        }()),
+                        endOfUrl: toSignAndEndOfUrl.endOfUrl,
+                        stringToSign: toSignAndEndOfUrl.toSign
+                    };
+                },
+
+                getHeaders: function() {
+                    return qq.extend({}, headers);
+                },
+
+                getEndOfUrl: function() {
+                    return toSignAndEndOfUrl && toSignAndEndOfUrl.endOfUrl;
+                }
+            };
+        }
+    });
+};
+
+qq.s3.RequestSigner.prototype.REQUEST_TYPE = {
+    MULTIPART_INITIATE: "multipart_initiate",
+    MULTIPART_COMPLETE: "multipart_complete",
+    MULTIPART_ABORT: "multipart_abort",
+    MULTIPART_UPLOAD: "multipart_upload"
+};
+
+/*globals qq, XMLHttpRequest*/
+/**
+ * Sends a POST request to the server to notify it of a successful upload to an endpoint.  The server is expected to indicate success
+ * or failure via the response status.  Specific information about the failure can be passed from the server via an `error`
+ * property (by default) in an "application/json" response.
+ *
+ * @param o Options associated with all requests.
+ * @constructor
+ */
+qq.UploadSuccessAjaxRequester = function(o) {
+    "use strict";
+
+    var requester,
+        pendingRequests = [],
+        options = {
+            method: "POST",
+            endpoint: null,
+            maxConnections: 3,
+            customHeaders: {},
+            paramsStore: {},
+            cors: {
+                expected: false,
+                sendCredentials: false
+            },
+            log: function(str, level) {}
+        };
+
+    qq.extend(options, o);
+
+    function handleSuccessResponse(id, xhrOrXdr, isError) {
+        var promise = pendingRequests[id],
+            responseJson = xhrOrXdr.responseText,
+            successIndicator = {success: true},
+            failureIndicator = {success: false},
+            parsedResponse;
+
+        delete pendingRequests[id];
+
+        options.log(qq.format("Received the following response body to an upload success request for id {}: {}", id, responseJson));
+
+        try {
+            parsedResponse = qq.parseJson(responseJson);
+
+            // If this is a cross-origin request, the server may return a 200 response w/ error or success properties
+            // in order to ensure any specific error message is picked up by Fine Uploader for all browsers,
+            // since XDomainRequest (used in IE9 and IE8) doesn't give you access to the
+            // response body for an "error" response.
+            if (isError || (parsedResponse && (parsedResponse.error || parsedResponse.success === false))) {
+                options.log("Upload success request was rejected by the server.", "error");
+                promise.failure(qq.extend(parsedResponse, failureIndicator));
+            }
+            else {
+                options.log("Upload success was acknowledged by the server.");
+                promise.success(qq.extend(parsedResponse, successIndicator));
+            }
+        }
+        catch (error) {
+            // This will be executed if a JSON response is not present.  This is not mandatory, so account for this properly.
+            if (isError) {
+                options.log(qq.format("Your server indicated failure in its upload success request response for id {}!", id), "error");
+                promise.failure(failureIndicator);
+            }
+            else {
+                options.log("Upload success was acknowledged by the server.");
+                promise.success(successIndicator);
+            }
+        }
+    }
+
+    requester = qq.extend(this, new qq.AjaxRequester({
+        acceptHeader: "application/json",
+        method: options.method,
+        endpointStore: {
+            get: function() {
+                return options.endpoint;
+            }
+        },
+        paramsStore: options.paramsStore,
+        maxConnections: options.maxConnections,
+        customHeaders: options.customHeaders,
+        log: options.log,
+        onComplete: handleSuccessResponse,
+        cors: options.cors
+    }));
+
+    qq.extend(this, {
+        /**
+         * Sends a request to the server, notifying it that a recently submitted file was successfully sent.
+         *
+         * @param id ID of the associated file
+         * @param spec `Object` with the properties that correspond to important values that we want to
+         * send to the server with this request.
+         * @returns {qq.Promise} A promise to be fulfilled when the response has been received and parsed.  The parsed
+         * payload of the response will be passed into the `failure` or `success` promise method.
+         */
+        sendSuccessRequest: function(id, spec) {
+            var promise = new qq.Promise();
+
+            options.log("Submitting upload success request/notification for " + id);
+
+            requester.initTransport(id)
+                .withParams(spec)
+                .send();
+
+            pendingRequests[id] = promise;
+
+            return promise;
+        }
+    });
+};
+
+/*globals qq*/
+/**
+ * Ajax requester used to send an ["Initiate Multipart Upload"](http://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ * request to S3 via the REST API.
+ *
+ * @param o Options from the caller - will override the defaults.
+ * @constructor
+ */
+qq.s3.InitiateMultipartAjaxRequester = function(o) {
+    "use strict";
+
+    var requester,
+        pendingInitiateRequests = {},
+        options = {
+            filenameParam: "qqfilename",
+            method: "POST",
+            endpointStore: null,
+            paramsStore: null,
+            signatureSpec: null,
+            aclStore: null,
+            reducedRedundancy: false,
+            serverSideEncryption: false,
+            maxConnections: 3,
+            getContentType: function(id) {},
+            getBucket: function(id) {},
+            getKey: function(id) {},
+            getName: function(id) {},
+            log: function(str, level) {}
+        },
+        getSignatureAjaxRequester;
+
+    qq.extend(options, o);
+
+    getSignatureAjaxRequester = new qq.s3.RequestSigner({
+        signatureSpec: options.signatureSpec,
+        cors: options.cors,
+        log: options.log
+    });
+
+    /**
+     * Determine all headers for the "Initiate MPU" request, including the "Authorization" header, which must be determined
+     * by the local server.  This is a promissory function.  If the server responds with a signature, the headers
+     * (including the Authorization header) will be passed into the success method of the promise.  Otherwise, the failure
+     * method on the promise will be called.
+     *
+     * @param id Associated file ID
+     * @returns {qq.Promise}
+     */
+    function getHeaders(id) {
+        var bucket = options.getBucket(id),
+            headers = {},
+            promise = new qq.Promise(),
+            key = options.getKey(id),
+            signatureConstructor;
+
+        headers["x-amz-acl"] = options.aclStore.get(id);
+
+        if (options.reducedRedundancy) {
+            headers[qq.s3.util.REDUCED_REDUNDANCY_PARAM_NAME] = qq.s3.util.REDUCED_REDUNDANCY_PARAM_VALUE;
+        }
+
+        if (options.serverSideEncryption) {
+            headers[qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_NAME] = qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_VALUE;
+        }
+
+        headers[qq.s3.util.AWS_PARAM_PREFIX + options.filenameParam] = encodeURIComponent(options.getName(id));
+
+        qq.each(options.paramsStore.get(id), function(name, val) {
+            headers[qq.s3.util.AWS_PARAM_PREFIX + name] = encodeURIComponent(val);
+        });
+
+        signatureConstructor = getSignatureAjaxRequester.constructStringToSign
+            (getSignatureAjaxRequester.REQUEST_TYPE.MULTIPART_INITIATE, bucket, key)
+            .withContentType(options.getContentType(id))
+            .withHeaders(headers);
+
+        // Ask the local server to sign the request.  Use this signature to form the Authorization header.
+        getSignatureAjaxRequester.getSignature(id, {signatureConstructor: signatureConstructor}).then(function(response) {
+            headers = signatureConstructor.getHeaders();
+            headers.Authorization = "AWS " + options.signatureSpec.credentialsProvider.get().accessKey + ":" + response.signature;
+            promise.success(headers, signatureConstructor.getEndOfUrl());
+        }, promise.failure);
+
+        return promise;
+    }
+
+    /**
+     * Called by the base ajax requester when the response has been received.  We definitively determine here if the
+     * "Initiate MPU" request has been a success or not.
+     *
+     * @param id ID associated with the file.
+     * @param xhr `XMLHttpRequest` object containing the response, among other things.
+     * @param isError A boolean indicating success or failure according to the base ajax requester (primarily based on status code).
+     */
+    function handleInitiateRequestComplete(id, xhr, isError) {
+        var promise = pendingInitiateRequests[id],
+            domParser = new DOMParser(),
+            responseDoc = domParser.parseFromString(xhr.responseText, "application/xml"),
+            uploadIdElements, messageElements, uploadId, errorMessage, status;
+
+        delete pendingInitiateRequests[id];
+
+        // The base ajax requester may declare the request to be a failure based on status code.
+        if (isError) {
+            status = xhr.status;
+
+            messageElements = responseDoc.getElementsByTagName("Message");
+            if (messageElements.length > 0) {
+                errorMessage = messageElements[0].textContent;
+            }
+        }
+        // If the base ajax requester has not declared this a failure, make sure we can retrieve the uploadId from the response.
+        else {
+            uploadIdElements = responseDoc.getElementsByTagName("UploadId");
+            if (uploadIdElements.length > 0) {
+                uploadId = uploadIdElements[0].textContent;
+            }
+            else {
+                errorMessage = "Upload ID missing from request";
+            }
+        }
+
+        // Either fail the promise (passing a descriptive error message) or declare it a success (passing the upload ID)
+        if (uploadId === undefined) {
+            if (errorMessage) {
+                options.log(qq.format("Specific problem detected initiating multipart upload request for {}: '{}'.", id, errorMessage), "error");
+            }
+            else {
+                options.log(qq.format("Unexplained error with initiate multipart upload request for {}.  Status code {}.", id, status), "error");
+            }
+
+            promise.failure("Problem initiating upload request.", xhr);
+        }
+        else {
+            options.log(qq.format("Initiate multipart upload request successful for {}.  Upload ID is {}", id, uploadId));
+            promise.success(uploadId, xhr);
+        }
+    }
+
+    requester = qq.extend(this, new qq.AjaxRequester({
+        method: options.method,
+        contentType: null,
+        endpointStore: options.endpointStore,
+        maxConnections: options.maxConnections,
+        allowXRequestedWithAndCacheControl: false, //These headers are not necessary & would break some installations if added
+        log: options.log,
+        onComplete: handleInitiateRequestComplete,
+        successfulResponseCodes: {
+            POST: [200]
+        }
+    }));
+
+    qq.extend(this, {
+        /**
+         * Sends the "Initiate MPU" request to AWS via the REST API.  First, though, we must get a signature from the
+         * local server for the request.  If all is successful, the uploadId from AWS will be passed into the promise's
+         * success handler. Otherwise, an error message will ultimately be passed into the failure method.
+         *
+         * @param id The ID associated with the file
+         * @returns {qq.Promise}
+         */
+        send: function(id) {
+            var promise = new qq.Promise();
+
+            getHeaders(id).then(function(headers, endOfUrl) {
+                options.log("Submitting S3 initiate multipart upload request for " + id);
+
+                pendingInitiateRequests[id] = promise;
+                requester.initTransport(id)
+                    .withPath(endOfUrl)
+                    .withHeaders(headers)
+                    .send();
+            }, promise.failure);
+
+            return promise;
+        }
+    });
+};
+
+/*globals qq*/
+/**
+ * Ajax requester used to send an ["Complete Multipart Upload"](http://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ * request to S3 via the REST API.
+ *
+ * @param o Options passed by the creator, to overwrite any default option values.
+ * @constructor
+ */
+qq.s3.CompleteMultipartAjaxRequester = function(o) {
+    "use strict";
+
+    var requester,
+        pendingCompleteRequests = {},
+        options = {
+            method: "POST",
+            contentType: "text/xml",
+            endpointStore: null,
+            signatureSpec: null,
+            maxConnections: 3,
+            getBucket: function(id) {},
+            getKey: function(id) {},
+            log: function(str, level) {}
+        },
+        getSignatureAjaxRequester;
+
+    qq.extend(options, o);
+
+    // Transport for requesting signatures (for the "Complete" requests) from the local server
+    getSignatureAjaxRequester = new qq.s3.RequestSigner({
+        signatureSpec: options.signatureSpec,
+        cors: options.cors,
+        log: options.log
+    });
+
+    /**
+     * Attach all required headers (including Authorization) to the "Complete" request.  This is a promissory function
+     * that will fulfill the associated promise once all headers have been attached or when an error has occurred that
+     * prevents headers from being attached.
+     *
+     * @param id Associated file ID
+     * @param uploadId ID of the associated upload, according to AWS
+     * @returns {qq.Promise}
+     */
+    function getHeaders(id, uploadId) {
+        var headers = {},
+            promise = new qq.Promise(),
+            bucket = options.getBucket(id),
+            signatureConstructor = getSignatureAjaxRequester.constructStringToSign
+                (getSignatureAjaxRequester.REQUEST_TYPE.MULTIPART_COMPLETE, bucket, options.getKey(id))
+                .withUploadId(uploadId)
+                .withContentType("application/xml; charset=UTF-8");
+
+        // Ask the local server to sign the request.  Use this signature to form the Authorization header.
+        getSignatureAjaxRequester.getSignature(id, {signatureConstructor: signatureConstructor}).then(function(response) {
+            headers = signatureConstructor.getHeaders();
+            headers.Authorization = "AWS " + options.signatureSpec.credentialsProvider.get().accessKey + ":" + response.signature;
+            promise.success(headers, signatureConstructor.getEndOfUrl());
+        }, promise.failure);
+
+        return promise;
+    }
+
+    /**
+     * Called by the base ajax requester when the response has been received.  We definitively determine here if the
+     * "Complete MPU" request has been a success or not.
+     *
+     * @param id ID associated with the file.
+     * @param xhr `XMLHttpRequest` object containing the response, among other things.
+     * @param isError A boolean indicating success or failure according to the base ajax requester (primarily based on status code).
+     */
+    function handleCompleteRequestComplete(id, xhr, isError) {
+        var promise = pendingCompleteRequests[id],
+            domParser = new DOMParser(),
+            bucket = options.getBucket(id),
+            key = options.getKey(id),
+            responseDoc = domParser.parseFromString(xhr.responseText, "application/xml"),
+            bucketEls = responseDoc.getElementsByTagName("Bucket"),
+            keyEls = responseDoc.getElementsByTagName("Key");
+
+        delete pendingCompleteRequests[id];
+
+        options.log(qq.format("Complete response status {}, body = {}", xhr.status, xhr.responseText));
+
+        // If the base requester has determine this a failure, give up.
+        if (isError) {
+            options.log(qq.format("Complete Multipart Upload request for {} failed with status {}.", id, xhr.status), "error");
+        }
+        else {
+            // Make sure the correct bucket and key has been specified in the XML response from AWS.
+            if (bucketEls.length && keyEls.length) {
+                if (bucketEls[0].textContent !== bucket) {
+                    isError = true;
+                    options.log(qq.format("Wrong bucket in response to Complete Multipart Upload request for {}.", id), "error");
+                }
+
+                // TODO Compare key name from response w/ expected key name if AWS ever fixes the encoding of key names in this response.
+            }
+            else {
+                isError = true;
+                options.log(qq.format("Missing bucket and/or key in response to Complete Multipart Upload request for {}.", id), "error");
+            }
+        }
+
+        if (isError) {
+            promise.failure("Problem combining the file parts!", xhr);
+        }
+        else {
+            promise.success({}, xhr);
+        }
+    }
+
+    /**
+     * @param etagEntries Array of objects containing `etag` values and their associated `part` numbers.
+     * @returns {string} XML string containing the body to send with the "Complete" request
+     */
+    function getCompleteRequestBody(etagEntries) {
+        var doc = document.implementation.createDocument(null, "CompleteMultipartUpload", null);
+
+        // The entries MUST be sorted by part number, per the AWS API spec.
+        etagEntries.sort(function(a, b) {
+            return a.part - b.part;
+        });
+
+        // Construct an XML document for each pair of etag/part values that correspond to part uploads.
+        qq.each(etagEntries, function(idx, etagEntry) {
+            var part = etagEntry.part,
+                etag = etagEntry.etag,
+                partEl = doc.createElement("Part"),
+                partNumEl = doc.createElement("PartNumber"),
+                partNumTextEl = doc.createTextNode(part),
+                etagTextEl = doc.createTextNode(etag),
+                etagEl = doc.createElement("ETag");
+
+            etagEl.appendChild(etagTextEl);
+            partNumEl.appendChild(partNumTextEl);
+            partEl.appendChild(partNumEl);
+            partEl.appendChild(etagEl);
+            qq(doc).children()[0].appendChild(partEl);
+        });
+
+        // Turn the resulting XML document into a string fit for transport.
+        return new XMLSerializer().serializeToString(doc);
+    }
+
+    requester = qq.extend(this, new qq.AjaxRequester({
+        method: options.method,
+        contentType: "application/xml; charset=UTF-8",
+        endpointStore: options.endpointStore,
+        maxConnections: options.maxConnections,
+        allowXRequestedWithAndCacheControl: false, //These headers are not necessary & would break some installations if added
+        log: options.log,
+        onComplete: handleCompleteRequestComplete,
+        successfulResponseCodes: {
+            POST: [200]
+        }
+    }));
+
+    qq.extend(this, {
+        /**
+         * Sends the "Complete" request and fulfills the returned promise when the success of this request is known.
+         *
+         * @param id ID associated with the file.
+         * @param uploadId AWS uploadId for this file
+         * @param etagEntries Array of objects containing `etag` values and their associated `part` numbers.
+         * @returns {qq.Promise}
+         */
+        send: function(id, uploadId, etagEntries) {
+            var promise = new qq.Promise();
+
+            getHeaders(id, uploadId).then(function(headers, endOfUrl) {
+                var body = getCompleteRequestBody(etagEntries);
+
+                options.log("Submitting S3 complete multipart upload request for " + id);
+
+                pendingCompleteRequests[id] = promise;
+                delete headers["Content-Type"];
+
+                requester.initTransport(id)
+                    .withPath(endOfUrl)
+                    .withHeaders(headers)
+                    .withPayload(body)
+                    .send();
+            }, promise.failure);
+
+            return promise;
+        }
+    });
+};
+
+/*globals qq */
+/**
+ * Ajax requester used to send an ["Abort Multipart Upload"](http://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadAbort.html)
+ * request to S3 via the REST API.
+
+ * @param o
+ * @constructor
+ */
+qq.s3.AbortMultipartAjaxRequester = function(o) {
+    "use strict";
+
+    var requester,
+        options = {
+            method: "DELETE",
+            endpointStore: null,
+            signatureSpec: null,
+            maxConnections: 3,
+            getBucket: function(id) {},
+            getKey: function(id) {},
+            log: function(str, level) {}
+        },
+        getSignatureAjaxRequester;
+
+    qq.extend(options, o);
+
+    // Transport for requesting signatures (for the "Complete" requests) from the local server
+    getSignatureAjaxRequester = new qq.s3.RequestSigner({
+        signatureSpec: options.signatureSpec,
+        cors: options.cors,
+        log: options.log
+    });
+
+    /**
+     * Attach all required headers (including Authorization) to the "Abort" request.  This is a promissory function
+     * that will fulfill the associated promise once all headers have been attached or when an error has occurred that
+     * prevents headers from being attached.
+     *
+     * @param id Associated file ID
+     * @param uploadId ID of the associated upload, according to AWS
+     * @returns {qq.Promise}
+     */
+    function getHeaders(id, uploadId) {
+        var headers = {},
+            promise = new qq.Promise(),
+            endpoint = options.endpointStore.get(id),
+            bucket = options.getBucket(id),
+            signatureConstructor = getSignatureAjaxRequester.constructStringToSign
+                (getSignatureAjaxRequester.REQUEST_TYPE.MULTIPART_ABORT, bucket, options.getKey(id))
+                .withUploadId(uploadId);
+
+        // Ask the local server to sign the request.  Use this signature to form the Authorization header.
+        getSignatureAjaxRequester.getSignature(id, {signatureConstructor: signatureConstructor}).then(function(response) {
+            headers = signatureConstructor.getHeaders();
+            headers.Authorization = "AWS " + options.signatureSpec.credentialsProvider.get().accessKey + ":" + response.signature;
+            promise.success(headers, signatureConstructor.getEndOfUrl());
+        }, promise.failure);
+
+        return promise;
+    }
+
+    /**
+     * Called by the base ajax requester when the response has been received.  We definitively determine here if the
+     * "Abort MPU" request has been a success or not.
+     *
+     * @param id ID associated with the file.
+     * @param xhr `XMLHttpRequest` object containing the response, among other things.
+     * @param isError A boolean indicating success or failure according to the base ajax requester (primarily based on status code).
+     */
+    function handleAbortRequestComplete(id, xhr, isError) {
+        var domParser = new DOMParser(),
+            responseDoc = domParser.parseFromString(xhr.responseText, "application/xml"),
+            errorEls = responseDoc.getElementsByTagName("Error"),
+            awsErrorMsg;
+
+        options.log(qq.format("Abort response status {}, body = {}", xhr.status, xhr.responseText));
+
+        // If the base requester has determine this a failure, give up.
+        if (isError) {
+            options.log(qq.format("Abort Multipart Upload request for {} failed with status {}.", id, xhr.status), "error");
+        }
+        else {
+            // Make sure the correct bucket and key has been specified in the XML response from AWS.
+            if (errorEls.length) {
+                isError = true;
+                awsErrorMsg = responseDoc.getElementsByTagName("Message")[0].textContent;
+                options.log(qq.format("Failed to Abort Multipart Upload request for {}.  Error: {}", id, awsErrorMsg), "error");
+            }
+            else {
+                options.log(qq.format("Abort MPU request succeeded for file ID {}.", id));
+            }
+        }
+    }
+
+    requester = qq.extend(this, new qq.AjaxRequester({
+        validMethods: ["DELETE"],
+        method: options.method,
+        contentType: null,
+        endpointStore: options.endpointStore,
+        maxConnections: options.maxConnections,
+        allowXRequestedWithAndCacheControl: false, //These headers are not necessary & would break some installations if added
+        log: options.log,
+        onComplete: handleAbortRequestComplete,
+        successfulResponseCodes: {
+            DELETE: [204]
+        }
+    }));
+
+    qq.extend(this, {
+        /**
+         * Sends the "Abort" request.
+         *
+         * @param id ID associated with the file.
+         * @param uploadId AWS uploadId for this file
+         */
+        send: function(id, uploadId) {
+            getHeaders(id, uploadId).then(function(headers, endOfUrl) {
+                options.log("Submitting S3 Abort multipart upload request for " + id);
+                requester.initTransport(id)
+                    .withPath(endOfUrl)
+                    .withHeaders(headers)
+                    .send();
+            });
+        }
+    });
+};
+
+/*globals qq */
+/**
+ * Upload handler used by the upload to S3 module that depends on File API support, and, therefore, makes use of
+ * `XMLHttpRequest` level 2 to upload `File`s and `Blob`s directly to S3 buckets via the associated AWS API.
+ *
+ * If chunking is supported and enabled, the S3 Multipart Upload REST API is utilized.
+ *
+ * @param spec Options passed from the base handler
+ * @param proxy Callbacks & methods used to query for or push out data/changes
+ */
+qq.s3.XhrUploadHandler = function(spec, proxy) {
+    "use strict";
+
+    var getName = proxy.getName,
+        log = proxy.log,
+        expectedStatus = 200,
+        onGetBucket = spec.getBucket,
+        onGetKeyName = spec.getKeyName,
+        filenameParam = spec.filenameParam,
+        paramsStore = spec.paramsStore,
+        endpointStore = spec.endpointStore,
+        aclStore = spec.aclStore,
+        reducedRedundancy = spec.objectProperties.reducedRedundancy,
+        serverSideEncryption = spec.objectProperties.serverSideEncryption,
+        validation = spec.validation,
+        signature = spec.signature,
+        handler = this,
+        credentialsProvider = spec.signature.credentialsProvider,
+
+        chunked = {
+            // Sends a "Complete Multipart Upload" request and then signals completion of the upload
+            // when the response to this request has been parsed.
+            combine: function(id) {
+                var uploadId = handler._getPersistableData(id).uploadId,
+                    etagMap = handler._getPersistableData(id).etags,
+                    result = new qq.Promise();
+
+                requesters.completeMultipart.send(id, uploadId, etagMap).then(
+                    result.success,
+
+                    function failure(reason, xhr) {
+                        result.failure(upload.done(id, xhr).response, xhr);
+                    }
+                );
+
+                return result;
+            },
+
+            // The last step in handling a chunked upload.  This is called after each chunk has been sent.
+            // The request may be successful, or not.  If it was successful, we must extract the "ETag" element
+            // in the XML response and store that along with the associated part number.
+            // We need these items to "Complete" the multipart upload after all chunks have been successfully sent.
+            done: function(id, xhr, chunkIdx) {
+                var response = upload.response.parse(id, xhr),
+                    etag;
+
+                if (response.success) {
+                    etag = xhr.getResponseHeader("ETag");
+
+                    if (!handler._getPersistableData(id).etags) {
+                        handler._getPersistableData(id).etags = [];
+                    }
+                    handler._getPersistableData(id).etags.push({part: chunkIdx + 1, etag: etag});
+                }
+            },
+
+            /**
+             * Determines headers that must be attached to the chunked (Multipart Upload) request.  One of these headers is an
+             * Authorization value, which must be determined by asking the local server to sign the request first.  So, this
+             * function returns a promise.  Once all headers are determined, the `success` method of the promise is called with
+             * the headers object.  If there was some problem determining the headers, we delegate to the caller's `failure`
+             * callback.
+             *
+             * @param id File ID
+             * @param chunkIdx Index of the chunk to PUT
+             * @returns {qq.Promise}
+             */
+            initHeaders: function(id, chunkIdx) {
+                var headers = {},
+                    endpoint = spec.endpointStore.get(id),
+                    bucket = upload.bucket.getName(id),
+                    key = upload.key.urlSafe(id),
+                    promise = new qq.Promise(),
+                    signatureConstructor = requesters.restSignature.constructStringToSign
+                        (requesters.restSignature.REQUEST_TYPE.MULTIPART_UPLOAD, bucket, key)
+                        .withPartNum(chunkIdx + 1)
+                        .withUploadId(handler._getPersistableData(id).uploadId);
+
+                // Ask the local server to sign the request.  Use this signature to form the Authorization header.
+                requesters.restSignature.getSignature(id + "." + chunkIdx, {signatureConstructor: signatureConstructor}).then(function(response) {
+                    headers = signatureConstructor.getHeaders();
+                    headers.Authorization = "AWS " + credentialsProvider.get().accessKey + ":" + response.signature;
+                    promise.success(headers, signatureConstructor.getEndOfUrl());
+                }, promise.failure);
+
+                return promise;
+            },
+
+            put: function(id, chunkIdx) {
+                var xhr = handler._createXhr(id, chunkIdx),
+                    chunkData = handler._getChunkData(id, chunkIdx),
+                    domain = spec.endpointStore.get(id),
+                    promise = new qq.Promise();
+
+                // Add appropriate headers to the multipart upload request.
+                // Once these have been determined (asynchronously) attach the headers and send the chunk.
+                chunked.initHeaders(id, chunkIdx).then(function(headers, endOfUrl) {
+                    var url = domain + "/" + endOfUrl;
+                    handler._registerProgressHandler(id, chunkIdx, chunkData.size);
+                    upload.track(id, xhr, chunkIdx).then(promise.success, promise.failure);
+                    xhr.open("PUT", url, true);
+
+                    qq.each(headers, function(name, val) {
+                        xhr.setRequestHeader(name, val);
+                    });
+
+                    xhr.send(chunkData.blob);
+                }, function() {
+                    promise.failure({error: "Problem signing the chunk!"}, xhr);
+                });
+
+                return promise;
+            },
+
+            send: function(id, chunkIdx) {
+                var promise = new qq.Promise();
+
+                chunked.setup(id).then(
+                    // The "Initiate" request succeeded.  We are ready to send the first chunk.
+                    function() {
+                        chunked.put(id, chunkIdx).then(promise.success, promise.failure);
+                    },
+
+                    // We were unable to initiate the chunked upload process.
+                    function(errorMessage, xhr) {
+                        promise.failure({error: errorMessage}, xhr);
+                    }
+                );
+
+                return promise;
+            },
+
+            /**
+             * Sends an "Initiate Multipart Upload" request to S3 via the REST API, but only if the MPU has not already been
+             * initiated.
+             *
+             * @param id Associated file ID
+             * @returns {qq.Promise} A promise that is fulfilled when the initiate request has been sent and the response has been parsed.
+             */
+            setup: function(id) {
+                var promise = new qq.Promise(),
+                    uploadId = handler._getPersistableData(id).uploadId,
+                    uploadIdPromise = new qq.Promise();
+
+                if (!uploadId) {
+                    handler._getPersistableData(id).uploadId = uploadIdPromise;
+                    requesters.initiateMultipart.send(id).then(
+                        function(uploadId) {
+                            handler._getPersistableData(id).uploadId = uploadId;
+                            uploadIdPromise.success(uploadId);
+                            promise.success(uploadId);
+                        },
+                        function(errorMsg) {
+                            handler._getPersistableData(id).uploadId = null;
+                            promise.failure(errorMsg);
+                            uploadIdPromise.failure(errorMsg);
+                        }
+                    );
+                }
+                else if (uploadId instanceof qq.Promise) {
+                    uploadId.then(function(uploadId) {
+                        promise.success(uploadId);
+                    });
+                }
+                else {
+                    promise.success(uploadId);
+                }
+
+                return promise;
+            }
+        },
+
+        requesters = {
+            abortMultipart: new qq.s3.AbortMultipartAjaxRequester({
+                endpointStore: endpointStore,
+                signatureSpec: signature,
+                cors: spec.cors,
+                log: log,
+                getBucket: function(id) {
+                    return upload.bucket.getName(id);
+                },
+                getKey: function(id) {
+                    return upload.key.urlSafe(id);
+                }
+            }),
+
+            completeMultipart: new qq.s3.CompleteMultipartAjaxRequester({
+                endpointStore: endpointStore,
+                signatureSpec: signature,
+                cors: spec.cors,
+                log: log,
+                getBucket: function(id) {
+                    return upload.bucket.getName(id);
+                },
+                getKey: function(id) {
+                    return upload.key.urlSafe(id);
+                }
+            }),
+
+            initiateMultipart: new qq.s3.InitiateMultipartAjaxRequester({
+                filenameParam: filenameParam,
+                endpointStore: endpointStore,
+                paramsStore: paramsStore,
+                signatureSpec: signature,
+                aclStore: aclStore,
+                reducedRedundancy: reducedRedundancy,
+                serverSideEncryption: serverSideEncryption,
+                cors: spec.cors,
+                log: log,
+                getContentType: function(id) {
+                    return handler._getMimeType(id);
+                },
+                getBucket: function(id) {
+                    return upload.bucket.getName(id);
+                },
+                getKey: function(id) {
+                    return upload.key.urlSafe(id);
+                },
+                getName: function(id) {
+                    return getName(id);
+                }
+            }),
+
+            policySignature: new qq.s3.RequestSigner({
+                expectingPolicy: true,
+                signatureSpec: signature,
+                cors: spec.cors,
+                log: log
+            }),
+
+            restSignature: new qq.s3.RequestSigner({
+                signatureSpec: signature,
+                cors: spec.cors,
+                log: log
+            })
+        },
+
+        simple = {
+            /**
+             * Used for simple (non-chunked) uploads to determine the parameters to send along with the request.  Part of this
+             * process involves asking the local server to sign the request, so this function returns a promise.  The promise
+             * is fulfilled when all parameters are determined, or when we determine that all parameters cannnot be calculated
+             * due to some error.
+             *
+             * @param id File ID
+             * @returns {qq.Promise}
+             */
+            initParams: function(id) {
+                /*jshint -W040 */
+                var customParams = paramsStore.get(id);
+                customParams[filenameParam] = getName(id);
+
+                return qq.s3.util.generateAwsParams({
+                    endpoint: endpointStore.get(id),
+                    params: customParams,
+                    type: handler._getMimeType(id),
+                    bucket: upload.bucket.getName(id),
+                    key: handler.getThirdPartyFileId(id),
+                    accessKey: credentialsProvider.get().accessKey,
+                    sessionToken: credentialsProvider.get().sessionToken,
+                    acl: aclStore.get(id),
+                    expectedStatus: expectedStatus,
+                    minFileSize: validation.minSizeLimit,
+                    maxFileSize: validation.maxSizeLimit,
+                    reducedRedundancy: reducedRedundancy,
+                    serverSideEncryption: serverSideEncryption,
+                    log: log
+                },
+                qq.bind(requesters.policySignature.getSignature, this, id));
+            },
+
+            send: function(id) {
+                var promise = new qq.Promise(),
+                    xhr = handler._createXhr(id),
+                    fileOrBlob = handler.getFile(id);
+
+                handler._registerProgressHandler(id);
+                upload.track(id, xhr).then(promise.success, promise.failure);
+
+                // Delegate to a function the sets up the XHR request and notifies us when it is ready to be sent, along w/ the payload.
+                simple.setup(id, xhr, fileOrBlob).then(function(toSend) {
+                    log("Sending upload request for " + id);
+                    xhr.send(toSend);
+                }, promise.failure);
+
+                return promise;
+            },
+
+            /**
+             * Starts the upload process by delegating to an async function that determine parameters to be attached to the
+             * request.  If all params can be determined, we are called back with the params and the caller of this function is
+             * informed by invoking the `success` method on the promise returned by this function, passing the payload of the
+             * request.  If some error occurs here, we delegate to a function that signals a failure for this upload attempt.
+             *
+             * Note that this is only used by the simple (non-chunked) upload process.
+             *
+             * @param id File ID
+             * @param xhr XMLHttpRequest to use for the upload
+             * @param fileOrBlob `File` or `Blob` to send
+             * @returns {qq.Promise}
+             */
+            setup: function(id, xhr, fileOrBlob) {
+                var formData = new FormData(),
+                    endpoint = endpointStore.get(id),
+                    url = endpoint,
+                    promise = new qq.Promise();
+
+                simple.initParams(id).then(
+                    // Success - all params determined
+                    function(awsParams) {
+                        xhr.open("POST", url, true);
+
+                        qq.obj2FormData(awsParams, formData);
+
+                        // AWS requires the file field be named "file".
+                        formData.append("file", fileOrBlob);
+
+                        promise.success(formData);
+                    },
+
+                    // Failure - we couldn't determine some params (likely the signature)
+                    function(errorMessage) {
+                        promise.failure({error: errorMessage});
+                    }
+                );
+
+                return promise;
+            }
+        },
+
+        upload = {
+            /**
+             * Note that this is called when an upload has reached a termination point,
+             * regardless of success/failure.  For example, it is called when we have
+             * encountered an error during the upload or when the file may have uploaded successfully.
+             *
+             * @param id file ID
+             */
+            bucket: {
+                promise: function(id) {
+                    var promise = new qq.Promise(),
+                        cachedBucket = handler._getFileState(id).bucket;
+
+                    if (cachedBucket) {
+                        promise.success(cachedBucket);
+                    }
+                    else {
+                        onGetBucket(id).then(function(bucket) {
+                            handler._getFileState(id).bucket = bucket;
+                            promise.success(bucket);
+                        }, promise.failure);
+                    }
+
+                    return promise;
+                },
+
+                getName: function(id) {
+                    return handler._getFileState(id).bucket;
+                }
+            },
+
+            done: function(id, xhr) {
+                var response = upload.response.parse(id, xhr),
+                    isError = response.success !== true;
+
+                if (isError && upload.response.shouldReset(response.code)) {
+                    log("This is an unrecoverable error, we must restart the upload entirely on the next retry attempt.", "error");
+                    response.reset = true;
+                }
+
+                return {
+                    success: !isError,
+                    response: response
+                };
+            },
+
+            key: {
+                promise: function(id) {
+                    var promise = new qq.Promise(),
+                        key = handler.getThirdPartyFileId(id);
+
+                    /* jshint eqnull:true */
+                    if (key == null) {
+                        handler._setThirdPartyFileId(id, promise);
+                        onGetKeyName(id, getName(id)).then(
+                            function(keyName) {
+                                handler._setThirdPartyFileId(id, keyName);
+                                promise.success(keyName);
+                            },
+                            function(errorReason) {
+                                handler._setThirdPartyFileId(id, null);
+                                promise.failure(errorReason);
+                            }
+                        );
+                    }
+                    else if (qq.isGenericPromise(key)) {
+                        key.then(promise.success, promise.failure);
+                    }
+                    else {
+                        promise.success(key);
+                    }
+
+                    return promise;
+                },
+
+                urlSafe: function(id) {
+                    return encodeURIComponent(handler.getThirdPartyFileId(id));
+                }
+            },
+
+            response: {
+                parse: function(id, xhr) {
+                    var response = {},
+                        parsedErrorProps;
+
+                    try {
+                        log(qq.format("Received response status {} with body: {}", xhr.status, xhr.responseText));
+
+                        if (xhr.status === expectedStatus) {
+                            response.success = true;
+                        }
+                        else {
+                            parsedErrorProps = upload.response.parseError(xhr.responseText);
+
+                            if (parsedErrorProps) {
+                                response.error = parsedErrorProps.message;
+                                response.code = parsedErrorProps.code;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        log("Error when attempting to parse xhr response text (" + error.message + ")", "error");
+                    }
+
+                    return response;
+                },
+
+                /**
+                 * This parses an XML response by extracting the "Message" and "Code" elements that accompany AWS error responses.
+                 *
+                 * @param awsResponseXml XML response from AWS
+                 * @returns {object} Object w/ `code` and `message` properties, or undefined if we couldn't find error info in the XML document.
+                 */
+                parseError: function(awsResponseXml) {
+                    var parser = new DOMParser(),
+                        parsedDoc = parser.parseFromString(awsResponseXml, "application/xml"),
+                        errorEls = parsedDoc.getElementsByTagName("Error"),
+                        errorDetails = {},
+                        codeEls, messageEls;
+
+                    if (errorEls.length) {
+                        codeEls = parsedDoc.getElementsByTagName("Code");
+                        messageEls = parsedDoc.getElementsByTagName("Message");
+
+                        if (messageEls.length) {
+                            errorDetails.message = messageEls[0].textContent;
+                        }
+
+                        if (codeEls.length) {
+                            errorDetails.code = codeEls[0].textContent;
+                        }
+
+                        return errorDetails;
+                    }
+                },
+
+                // Determine if the upload should be restarted on the next retry attempt
+                // based on the error code returned in the response from AWS.
+                shouldReset: function(errorCode) {
+                    /*jshint -W014 */
+                    return errorCode === "EntityTooSmall"
+                        || errorCode === "InvalidPart"
+                        || errorCode === "InvalidPartOrder"
+                        || errorCode === "NoSuchUpload";
+                }
+            },
+
+            start: function(id, optChunkIdx) {
+                var promise = new qq.Promise();
+
+                upload.key.promise(id).then(function() {
+                    upload.bucket.promise(id).then(function() {
+                        /* jshint eqnull:true */
+                        if (optChunkIdx == null) {
+                            simple.send(id).then(promise.success, promise.failure);
+                        }
+                        else {
+                            chunked.send(id, optChunkIdx).then(promise.success, promise.failure);
+                        }
+                    });
+                },
+                function(errorReason) {
+                    promise.failure({error: errorReason});
+                });
+
+                return promise;
+            },
+
+            track: function(id, xhr, optChunkIdx) {
+                var promise = new qq.Promise();
+
+                xhr.onreadystatechange = function() {
+                    if (xhr.readyState === 4) {
+                        var result;
+
+                        /* jshint eqnull:true */
+                        if (optChunkIdx == null) {
+                            result = upload.done(id, xhr);
+                            promise[result.success ? "success" : "failure"](result.response, xhr);
+                        }
+                        else {
+                            chunked.done(id, xhr, optChunkIdx);
+                            result = upload.done(id, xhr);
+                            promise[result.success ? "success" : "failure"](result.response, xhr);
+                        }
+                    }
+                };
+
+                return promise;
+            }
+        };
+
+    qq.extend(this, {
+        uploadChunk: upload.start,
+        uploadFile: upload.start
+    });
+
+    qq.extend(this, new qq.XhrUploadHandler({
+        options: qq.extend({namespace: "s3"}, spec),
+        proxy: qq.extend({getEndpoint: spec.endpointStore.get}, proxy)
+    }));
+
+    qq.override(this, function(super_) {
+        return {
+            expunge: function(id) {
+                var uploadId = handler._getPersistableData(id) && handler._getPersistableData(id).uploadId,
+                    existedInLocalStorage = handler._maybeDeletePersistedChunkData(id);
+
+                if (uploadId !== undefined && existedInLocalStorage) {
+                    requesters.abortMultipart.send(id, uploadId);
+                }
+
+                super_.expunge(id);
+            },
+
+            finalizeChunks: function(id) {
+                return chunked.combine(id);
+            },
+
+            _getLocalStorageId: function(id) {
+                var baseStorageId = super_._getLocalStorageId(id),
+                    bucketName = upload.bucket.getName(id);
+
+                return baseStorageId + "-" + bucketName;
+            }
+        };
+    });
+};
+
+/*globals qq */
+/**
+ * Upload handler used by the upload to S3 module that assumes the current user agent does not have any support for the
+ * File API, and, therefore, makes use of iframes and forms to submit the files directly to S3 buckets via the associated
+ * AWS API.
+ *
+ * @param options Options passed from the base handler
+ * @param proxy Callbacks & methods used to query for or push out data/changes
+ */
+qq.s3.FormUploadHandler = function(options, proxy) {
+    "use strict";
+
+    var handler = this,
+        onUuidChanged = proxy.onUuidChanged,
+        getName = proxy.getName,
+        getUuid = proxy.getUuid,
+        log = proxy.log,
+        onGetBucket = options.getBucket,
+        onGetKeyName = options.getKeyName,
+        filenameParam = options.filenameParam,
+        paramsStore = options.paramsStore,
+        endpointStore = options.endpointStore,
+        aclStore = options.aclStore,
+        reducedRedundancy = options.objectProperties.reducedRedundancy,
+        serverSideEncryption = options.objectProperties.serverSideEncryption,
+        validation = options.validation,
+        signature = options.signature,
+        successRedirectUrl = options.iframeSupport.localBlankPagePath,
+        credentialsProvider = options.signature.credentialsProvider,
+        getSignatureAjaxRequester = new qq.s3.RequestSigner({
+            signatureSpec: signature,
+            cors: options.cors,
+            log: log
+        });
+
+    if (successRedirectUrl === undefined) {
+        throw new Error("successRedirectEndpoint MUST be defined if you intend to use browsers that do not support the File API!");
+    }
+
+    /**
+     * Attempt to parse the contents of an iframe after receiving a response from the server.  If the contents cannot be
+     * read (perhaps due to a security error) it is safe to assume that the upload was not successful since Amazon should
+     * have redirected to a known endpoint that should provide a parseable response.
+     *
+     * @param id ID of the associated file
+     * @param iframe target of the form submit
+     * @returns {boolean} true if the contents can be read, false otherwise
+     */
+    function isValidResponse(id, iframe) {
+        var response,
+            endpoint = options.endpointStore.get(id),
+            bucket = qq.s3.util.getBucket(endpoint),
+            doc,
+            innerHtml,
+            responseData;
+
+        //IE may throw an "access is denied" error when attempting to access contentDocument on the iframe in some cases
+        try {
+            // iframe.contentWindow.document - for IE<7
+            doc = iframe.contentDocument || iframe.contentWindow.document;
+            innerHtml = doc.body.innerHTML;
+
+            responseData = qq.s3.util.parseIframeResponse(iframe);
+            if (responseData.bucket === bucket &&
+                responseData.key === qq.s3.util.encodeQueryStringParam(handler.getThirdPartyFileId(id))) {
+
+                return true;
+            }
+
+            log("Response from AWS included an unexpected bucket or key name.", "error");
+
+        }
+        catch (error) {
+            log("Error when attempting to parse form upload response (" + error.message + ")", "error");
+        }
+
+        return false;
+    }
+
+    function generateAwsParams(id) {
+        /*jshint -W040 */
+        var customParams = paramsStore.get(id);
+
+        customParams[filenameParam] = getName(id);
+
+        return qq.s3.util.generateAwsParams({
+            endpoint: endpointStore.get(id),
+            params: customParams,
+            bucket: handler._getFileState(id).bucket,
+            key: handler.getThirdPartyFileId(id),
+            accessKey: credentialsProvider.get().accessKey,
+            sessionToken: credentialsProvider.get().sessionToken,
+            acl: aclStore.get(id),
+            minFileSize: validation.minSizeLimit,
+            maxFileSize: validation.maxSizeLimit,
+            successRedirectUrl: successRedirectUrl,
+            reducedRedundancy: reducedRedundancy,
+            serverSideEncryption: serverSideEncryption,
+            log: log
+        },
+        qq.bind(getSignatureAjaxRequester.getSignature, this, id));
+    }
+
+    /**
+     * Creates form, that will be submitted to iframe
+     */
+    function createForm(id, iframe) {
+        var promise = new qq.Promise(),
+            method = "POST",
+            endpoint = options.endpointStore.get(id),
+            fileName = getName(id);
+
+        generateAwsParams(id).then(function(params) {
+            var form = handler._initFormForUpload({
+                method: method,
+                endpoint: endpoint,
+                params: params,
+                paramsInBody: true,
+                targetName: iframe.name
+            });
+
+            promise.success(form);
+        }, function(errorMessage) {
+            promise.failure(errorMessage);
+            handleFinishedUpload(id, iframe, fileName, {error: errorMessage});
+        });
+
+        return promise;
+    }
+
+    function handleUpload(id) {
+        var iframe = handler._createIframe(id),
+            input = handler.getInput(id),
+            promise = new qq.Promise();
+
+        createForm(id, iframe).then(function(form) {
+            form.appendChild(input);
+
+            // Register a callback when the response comes in from S3
+            handler._attachLoadEvent(iframe, function(response) {
+                log("iframe loaded");
+
+                // If the common response handler has determined success or failure immediately
+                if (response) {
+                    // If there is something fundamentally wrong with the response (such as iframe content is not accessible)
+                    if (response.success === false) {
+                        log("Amazon likely rejected the upload request", "error");
+                        promise.failure(response);
+                    }
+                }
+                // The generic response (iframe onload) handler was not able to make a determination regarding the success of the request
+                else {
+                    response = {};
+                    response.success = isValidResponse(id, iframe);
+
+                    // If the more specific response handle detected a problem with the response from S3
+                    if (response.success === false) {
+                        log("A success response was received by Amazon, but it was invalid in some way.", "error");
+                        promise.failure(response);
+                    }
+                    else {
+                        qq.extend(response, qq.s3.util.parseIframeResponse(iframe));
+                        promise.success(response);
+                    }
+                }
+
+                handleFinishedUpload(id, iframe);
+            });
+
+            log("Sending upload request for " + id);
+            form.submit();
+            qq(form).remove();
+        }, promise.failure);
+
+        return promise;
+    }
+
+    function handleFinishedUpload(id, iframe) {
+        handler._detachLoadEvent(id);
+        iframe && qq(iframe).remove();
+    }
+
+    qq.extend(this, new qq.FormUploadHandler({
+        options: {
+            isCors: false,
+            inputName: "file"
+        },
+
+        proxy: {
+            onCancel: options.onCancel,
+            onUuidChanged: onUuidChanged,
+            getName: getName,
+            getUuid: getUuid,
+            log: log
+        }
+    }));
+
+    qq.extend(this, {
+        uploadFile: function(id) {
+            var name = getName(id),
+                promise = new qq.Promise();
+
+            if (handler.getThirdPartyFileId(id)) {
+                if (handler._getFileState(id).bucket) {
+                    handleUpload(id).then(promise.success, promise.failure);
+                }
+                else {
+                    onGetBucket(id).then(function(bucket) {
+                        handler._getFileState(id).bucket = bucket;
+                        handleUpload(id).then(promise.success, promise.failure);
+                    });
+                }
+            }
+            else {
+                // The S3 uploader module will either calculate the key or ask the server for it
+                // and will call us back once it is known.
+                onGetKeyName(id, name).then(function(key) {
+                    onGetBucket(id).then(function(bucket) {
+                        handler._getFileState(id).bucket = bucket;
+                        handler._setThirdPartyFileId(id, key);
+                        handleUpload(id).then(promise.success, promise.failure);
+                    }, function(errorReason) {
+                        promise.failure({error: errorReason});
+                    });
+                }, function(errorReason) {
+                    promise.failure({error: errorReason});
+                });
+            }
+
+            return promise;
+        }
+    });
+};
+
+/*globals qq */
+/**
+ * This defines FineUploader mode w/ support for uploading to S3, which provides all the basic
+ * functionality of Fine Uploader as well as code to handle uploads directly to S3.
+ * This module inherits all logic from FineUploader mode and FineUploaderBasicS3 mode and adds some UI-related logic
+ * specific to the upload-to-S3 workflow.  Some inherited options and API methods have a special meaning
+ * in the context of the S3 uploader.
+ */
+(function() {
+    "use strict";
+
+    qq.s3.FineUploader = function(o) {
+        var options = {
+            failedUploadTextDisplay: {
+                mode: "custom"
+            }
+        };
+
+        // Replace any default options with user defined ones
+        qq.extend(options, o, true);
+
+        // Inherit instance data from FineUploader, which should in turn inherit from s3.FineUploaderBasic.
+        qq.FineUploader.call(this, options, "s3");
+
+        if (!qq.supportedFeatures.ajaxUploading && options.iframeSupport.localBlankPagePath === undefined) {
+            this._options.element.innerHTML = "<div>You MUST set the <code>localBlankPagePath</code> property " +
+                "of the <code>iframeSupport</code> option since this browser does not support the File API!</div>";
+        }
+    };
+
+    // Inherit the API methods from FineUploaderBasicS3
+    qq.extend(qq.s3.FineUploader.prototype, qq.s3.FineUploaderBasic.prototype);
+
+    // Inherit public and private API methods related to UI
+    qq.extend(qq.s3.FineUploader.prototype, qq.uiPublicApi);
+    qq.extend(qq.s3.FineUploader.prototype, qq.uiPrivateApi);
+}());
+
+/*globals qq*/
+qq.PasteSupport = function(o) {
+    "use strict";
+
+    var options, detachPasteHandler;
+
+    options = {
+        targetElement: null,
+        callbacks: {
+            log: function(message, level) {},
+            pasteReceived: function(blob) {}
+        }
+    };
+
+    function isImage(item) {
+        return item.type &&
+            item.type.indexOf("image/") === 0;
+    }
+
+    function registerPasteHandler() {
+        detachPasteHandler = qq(options.targetElement).attach("paste", function(event) {
+            var clipboardData = event.clipboardData;
+
+            if (clipboardData) {
+                qq.each(clipboardData.items, function(idx, item) {
+                    if (isImage(item)) {
+                        var blob = item.getAsFile();
+                        options.callbacks.pasteReceived(blob);
+                    }
+                });
+            }
+        });
+    }
+
+    function unregisterPasteHandler() {
+        if (detachPasteHandler) {
+            detachPasteHandler();
+        }
+    }
+
+    qq.extend(options, o);
+    registerPasteHandler();
+
+    qq.extend(this, {
+        reset: function() {
+            unregisterPasteHandler();
+        }
+    });
+};
+
+/*globals qq, document, CustomEvent*/
+qq.DragAndDrop = function(o) {
+    "use strict";
+
+    var options,
+        HIDE_ZONES_EVENT_NAME = "qq-hidezones",
+        HIDE_BEFORE_ENTER_ATTR = "qq-hide-dropzone",
+        uploadDropZones = [],
+        droppedFiles = [],
+        disposeSupport = new qq.DisposeSupport();
+
+    options = {
+        dropZoneElements: [],
+        allowMultipleItems: true,
+        classes: {
+            dropActive: null
+        },
+        callbacks: new qq.DragAndDrop.callbacks()
+    };
+
+    qq.extend(options, o, true);
+
+    function uploadDroppedFiles(files, uploadDropZone) {
+        // We need to convert the `FileList` to an actual `Array` to avoid iteration issues
+        var filesAsArray = Array.prototype.slice.call(files);
+
+        options.callbacks.dropLog("Grabbed " + files.length + " dropped files.");
+        uploadDropZone.dropDisabled(false);
+        options.callbacks.processingDroppedFilesComplete(filesAsArray, uploadDropZone.getElement());
+    }
+
+    function traverseFileTree(entry) {
+        var parseEntryPromise = new qq.Promise();
+
+        if (entry.isFile) {
+            entry.file(function(file) {
+                var name = entry.name,
+                    fullPath = entry.fullPath,
+                    indexOfNameInFullPath = fullPath.indexOf(name);
+
+                // remove file name from full path string
+                fullPath = fullPath.substr(0, indexOfNameInFullPath);
+
+                // remove leading slash in full path string
+                if (fullPath.charAt(0) === "/") {
+                    fullPath = fullPath.substr(1);
+                }
+
+                file.qqPath = fullPath;
+                droppedFiles.push(file);
+                parseEntryPromise.success();
+            },
+            function(fileError) {
+                options.callbacks.dropLog("Problem parsing '" + entry.fullPath + "'.  FileError code " + fileError.code + ".", "error");
+                parseEntryPromise.failure();
+            });
+        }
+        else if (entry.isDirectory) {
+            getFilesInDirectory(entry).then(
+                function allEntriesRead(entries) {
+                    var entriesLeft = entries.length;
+
+                    qq.each(entries, function(idx, entry) {
+                        traverseFileTree(entry).done(function() {
+                            entriesLeft -= 1;
+
+                            if (entriesLeft === 0) {
+                                parseEntryPromise.success();
+                            }
+                        });
+                    });
+
+                    if (!entries.length) {
+                        parseEntryPromise.success();
+                    }
+                },
+
+                function readFailure(fileError) {
+                    options.callbacks.dropLog("Problem parsing '" + entry.fullPath + "'.  FileError code " + fileError.code + ".", "error");
+                    parseEntryPromise.failure();
+                }
+            );
+        }
+
+        return parseEntryPromise;
+    }
+
+    // Promissory.  Guaranteed to read all files in the root of the passed directory.
+    function getFilesInDirectory(entry, reader, accumEntries, existingPromise) {
+        var promise = existingPromise || new qq.Promise(),
+            dirReader = reader || entry.createReader();
+
+        dirReader.readEntries(
+            function readSuccess(entries) {
+                var newEntries = accumEntries ? accumEntries.concat(entries) : entries;
+
+                if (entries.length) {
+                    setTimeout(function() { // prevent stack oveflow, however unlikely
+                        getFilesInDirectory(entry, dirReader, newEntries, promise);
+                    }, 0);
+                }
+                else {
+                    promise.success(newEntries);
+                }
+            },
+
+            promise.failure
+        );
+
+        return promise;
+    }
+
+    function handleDataTransfer(dataTransfer, uploadDropZone) {
+        var pendingFolderPromises = [],
+            handleDataTransferPromise = new qq.Promise();
+
+        options.callbacks.processingDroppedFiles();
+        uploadDropZone.dropDisabled(true);
+
+        if (dataTransfer.files.length > 1 && !options.allowMultipleItems) {
+            options.callbacks.processingDroppedFilesComplete([]);
+            options.callbacks.dropError("tooManyFilesError", "");
+            uploadDropZone.dropDisabled(false);
+            handleDataTransferPromise.failure();
+        }
+        else {
+            droppedFiles = [];
+
+            if (qq.isFolderDropSupported(dataTransfer)) {
+                qq.each(dataTransfer.items, function(idx, item) {
+                    var entry = item.webkitGetAsEntry();
+
+                    if (entry) {
+                        //due to a bug in Chrome's File System API impl - #149735
+                        if (entry.isFile) {
+                            droppedFiles.push(item.getAsFile());
+                        }
+
+                        else {
+                            pendingFolderPromises.push(traverseFileTree(entry).done(function() {
+                                pendingFolderPromises.pop();
+                                if (pendingFolderPromises.length === 0) {
+                                    handleDataTransferPromise.success();
+                                }
+                            }));
+                        }
+                    }
+                });
+            }
+            else {
+                droppedFiles = dataTransfer.files;
+            }
+
+            if (pendingFolderPromises.length === 0) {
+                handleDataTransferPromise.success();
+            }
+        }
+
+        return handleDataTransferPromise;
+    }
+
+    function setupDropzone(dropArea) {
+        var dropZone = new qq.UploadDropZone({
+            HIDE_ZONES_EVENT_NAME: HIDE_ZONES_EVENT_NAME,
+            element: dropArea,
+            onEnter: function(e) {
+                qq(dropArea).addClass(options.classes.dropActive);
+                e.stopPropagation();
+            },
+            onLeaveNotDescendants: function(e) {
+                qq(dropArea).removeClass(options.classes.dropActive);
+            },
+            onDrop: function(e) {
+                handleDataTransfer(e.dataTransfer, dropZone).then(
+                    function() {
+                        uploadDroppedFiles(droppedFiles, dropZone);
+                    },
+                    function() {
+                        options.callbacks.dropLog("Drop event DataTransfer parsing failed.  No files will be uploaded.", "error");
+                    }
+                );
+            }
+        });
+
+        disposeSupport.addDisposer(function() {
+            dropZone.dispose();
+        });
+
+        qq(dropArea).hasAttribute(HIDE_BEFORE_ENTER_ATTR) && qq(dropArea).hide();
+
+        uploadDropZones.push(dropZone);
+
+        return dropZone;
+    }
+
+    function isFileDrag(dragEvent) {
+        var fileDrag;
+
+        qq.each(dragEvent.dataTransfer.types, function(key, val) {
+            if (val === "Files") {
+                fileDrag = true;
+                return false;
+            }
+        });
+
+        return fileDrag;
+    }
+
+    // Attempt to determine when the file has left the document.  It is not always possible to detect this
+    // in all cases, but it is generally possible in all browsers, with a few exceptions.
+    //
+    // Exceptions:
+    // * IE10+ & Safari: We can't detect a file leaving the document if the Explorer window housing the file
+    //                   overlays the browser window.
+    // * IE10+: If the file is dragged out of the window too quickly, IE does not set the expected values of the
+    //          event's X & Y properties.
+    function leavingDocumentOut(e) {
+        if (qq.firefox()) {
+            return !e.relatedTarget;
+        }
+
+        if (qq.safari()) {
+            return e.x < 0 || e.y < 0;
+        }
+
+        return e.x === 0 && e.y === 0;
+    }
+
+    function setupDragDrop() {
+        var dropZones = options.dropZoneElements,
+
+            maybeHideDropZones = function() {
+                setTimeout(function() {
+                    qq.each(dropZones, function(idx, dropZone) {
+                        qq(dropZone).hasAttribute(HIDE_BEFORE_ENTER_ATTR) && qq(dropZone).hide();
+                        qq(dropZone).removeClass(options.classes.dropActive);
+                    });
+                }, 10);
+            };
+
+        qq.each(dropZones, function(idx, dropZone) {
+            var uploadDropZone = setupDropzone(dropZone);
+
+            // IE <= 9 does not support the File API used for drag+drop uploads
+            if (dropZones.length && qq.supportedFeatures.fileDrop) {
+                disposeSupport.attach(document, "dragenter", function(e) {
+                    if (!uploadDropZone.dropDisabled() && isFileDrag(e)) {
+                        qq.each(dropZones, function(idx, dropZone) {
+                            // We can't apply styles to non-HTMLElements, since they lack the `style` property.
+                            // Also, if the drop zone isn't initially hidden, let's not mess with `style.display`.
+                            if (dropZone instanceof HTMLElement &&
+                                qq(dropZone).hasAttribute(HIDE_BEFORE_ENTER_ATTR)) {
+
+                                qq(dropZone).css({display: "block"});
+                            }
+                        });
+                    }
+                });
+            }
+        });
+
+        disposeSupport.attach(document, "dragleave", function(e) {
+            if (leavingDocumentOut(e)) {
+                maybeHideDropZones();
+            }
+        });
+
+        // Just in case we were not able to detect when a dragged file has left the document,
+        // hide all relevant drop zones the next time the mouse enters the document.
+        // Note that mouse events such as this one are not fired during drag operations.
+        disposeSupport.attach(qq(document).children()[0], "mouseenter", function(e) {
+            maybeHideDropZones();
+        });
+
+        disposeSupport.attach(document, "drop", function(e) {
+            e.preventDefault();
+            maybeHideDropZones();
+        });
+
+        disposeSupport.attach(document, HIDE_ZONES_EVENT_NAME, maybeHideDropZones);
+    }
+
+    setupDragDrop();
+
+    qq.extend(this, {
+        setupExtraDropzone: function(element) {
+            options.dropZoneElements.push(element);
+            setupDropzone(element);
+        },
+
+        removeDropzone: function(element) {
+            var i,
+                dzs = options.dropZoneElements;
+
+            for (i in dzs) {
+                if (dzs[i] === element) {
+                    return dzs.splice(i, 1);
+                }
+            }
+        },
+
+        dispose: function() {
+            disposeSupport.dispose();
+            qq.each(uploadDropZones, function(idx, dropZone) {
+                dropZone.dispose();
+            });
+        }
+    });
+};
+
+qq.DragAndDrop.callbacks = function() {
+    "use strict";
+
+    return {
+        processingDroppedFiles: function() {},
+        processingDroppedFilesComplete: function(files, targetEl) {},
+        dropError: function(code, errorSpecifics) {
+            qq.log("Drag & drop error code '" + code + " with these specifics: '" + errorSpecifics + "'", "error");
+        },
+        dropLog: function(message, level) {
+            qq.log(message, level);
+        }
+    };
+};
+
+qq.UploadDropZone = function(o) {
+    "use strict";
+
+    var disposeSupport = new qq.DisposeSupport(),
+        options, element, preventDrop, dropOutsideDisabled;
+
+    options = {
+        element: null,
+        onEnter: function(e) {},
+        onLeave: function(e) {},
+        // is not fired when leaving element by hovering descendants
+        onLeaveNotDescendants: function(e) {},
+        onDrop: function(e) {}
+    };
+
+    qq.extend(options, o);
+    element = options.element;
+
+    function dragoverShouldBeCanceled() {
+        return qq.safari() || (qq.firefox() && qq.windows());
+    }
+
+    function disableDropOutside(e) {
+        // run only once for all instances
+        if (!dropOutsideDisabled) {
+
+            // for these cases we need to catch onDrop to reset dropArea
+            if (dragoverShouldBeCanceled) {
+                disposeSupport.attach(document, "dragover", function(e) {
+                    e.preventDefault();
+                });
+            } else {
+                disposeSupport.attach(document, "dragover", function(e) {
+                    if (e.dataTransfer) {
+                        e.dataTransfer.dropEffect = "none";
+                        e.preventDefault();
+                    }
+                });
+            }
+
+            dropOutsideDisabled = true;
+        }
+    }
+
+    function isValidFileDrag(e) {
+        // e.dataTransfer currently causing IE errors
+        // IE9 does NOT support file API, so drag-and-drop is not possible
+        if (!qq.supportedFeatures.fileDrop) {
+            return false;
+        }
+
+        var effectTest, dt = e.dataTransfer,
+        // do not check dt.types.contains in webkit, because it crashes safari 4
+        isSafari = qq.safari();
+
+        // dt.effectAllowed is none in Safari 5
+        // dt.types.contains check is for firefox
+
+        // dt.effectAllowed crashes IE 11 & 10 when files have been dragged from
+        // the filesystem
+        effectTest = qq.ie() && qq.supportedFeatures.fileDrop ? true : dt.effectAllowed !== "none";
+        return dt && effectTest && (dt.files || (!isSafari && dt.types.contains && dt.types.contains("Files")));
+    }
+
+    function isOrSetDropDisabled(isDisabled) {
+        if (isDisabled !== undefined) {
+            preventDrop = isDisabled;
+        }
+        return preventDrop;
+    }
+
+    function triggerHidezonesEvent() {
+        var hideZonesEvent;
+
+        function triggerUsingOldApi() {
+            hideZonesEvent = document.createEvent("Event");
+            hideZonesEvent.initEvent(options.HIDE_ZONES_EVENT_NAME, true, true);
+        }
+
+        if (window.CustomEvent) {
+            try {
+                hideZonesEvent = new CustomEvent(options.HIDE_ZONES_EVENT_NAME);
+            }
+            catch (err) {
+                triggerUsingOldApi();
+            }
+        }
+        else {
+            triggerUsingOldApi();
+        }
+
+        document.dispatchEvent(hideZonesEvent);
+    }
+
+    function attachEvents() {
+        disposeSupport.attach(element, "dragover", function(e) {
+            if (!isValidFileDrag(e)) {
+                return;
+            }
+
+            // dt.effectAllowed crashes IE 11 & 10 when files have been dragged from
+            // the filesystem
+            var effect = qq.ie() && qq.supportedFeatures.fileDrop ? null : e.dataTransfer.effectAllowed;
+            if (effect === "move" || effect === "linkMove") {
+                e.dataTransfer.dropEffect = "move"; // for FF (only move allowed)
+            } else {
+                e.dataTransfer.dropEffect = "copy"; // for Chrome
+            }
+
+            e.stopPropagation();
+            e.preventDefault();
+        });
+
+        disposeSupport.attach(element, "dragenter", function(e) {
+            if (!isOrSetDropDisabled()) {
+                if (!isValidFileDrag(e)) {
+                    return;
+                }
+                options.onEnter(e);
+            }
+        });
+
+        disposeSupport.attach(element, "dragleave", function(e) {
+            if (!isValidFileDrag(e)) {
+                return;
+            }
+
+            options.onLeave(e);
+
+            var relatedTarget = document.elementFromPoint(e.clientX, e.clientY);
+            // do not fire when moving a mouse over a descendant
+            if (qq(this).contains(relatedTarget)) {
+                return;
+            }
+
+            options.onLeaveNotDescendants(e);
+        });
+
+        disposeSupport.attach(element, "drop", function(e) {
+            if (!isOrSetDropDisabled()) {
+                if (!isValidFileDrag(e)) {
+                    return;
+                }
+
+                e.preventDefault();
+                e.stopPropagation();
+                options.onDrop(e);
+
+                triggerHidezonesEvent();
+            }
+        });
+    }
+
+    disableDropOutside();
+    attachEvents();
+
+    qq.extend(this, {
+        dropDisabled: function(isDisabled) {
+            return isOrSetDropDisabled(isDisabled);
+        },
+
+        dispose: function() {
+            disposeSupport.dispose();
+        },
+
+        getElement: function() {
+            return element;
+        }
+    });
+};
+
+/*globals qq, XMLHttpRequest*/
+qq.DeleteFileAjaxRequester = function(o) {
+    "use strict";
+
+    var requester,
+        options = {
+            method: "DELETE",
+            uuidParamName: "qquuid",
+            endpointStore: {},
+            maxConnections: 3,
+            customHeaders: function(id) {return {};},
+            paramsStore: {},
+            cors: {
+                expected: false,
+                sendCredentials: false
+            },
+            log: function(str, level) {},
+            onDelete: function(id) {},
+            onDeleteComplete: function(id, xhrOrXdr, isError) {}
+        };
+
+    qq.extend(options, o);
+
+    function getMandatedParams() {
+        if (options.method.toUpperCase() === "POST") {
+            return {
+                _method: "DELETE"
+            };
+        }
+
+        return {};
+    }
+
+    requester = qq.extend(this, new qq.AjaxRequester({
+        acceptHeader: "application/json",
+        validMethods: ["POST", "DELETE"],
+        method: options.method,
+        endpointStore: options.endpointStore,
+        paramsStore: options.paramsStore,
+        mandatedParams: getMandatedParams(),
+        maxConnections: options.maxConnections,
+        customHeaders: function(id) {
+            return options.customHeaders.get(id);
+        },
+        log: options.log,
+        onSend: options.onDelete,
+        onComplete: options.onDeleteComplete,
+        cors: options.cors
+    }));
+
+    qq.extend(this, {
+        sendDelete: function(id, uuid, additionalMandatedParams) {
+            var additionalOptions = additionalMandatedParams || {};
+
+            options.log("Submitting delete file request for " + id);
+
+            if (options.method === "DELETE") {
+                requester.initTransport(id)
+                    .withPath(uuid)
+                    .withParams(additionalOptions)
+                    .send();
+            }
+            else {
+                additionalOptions[options.uuidParamName] = uuid;
+                requester.initTransport(id)
+                    .withParams(additionalOptions)
+                    .send();
+            }
+        }
+    });
+};
+
+/*global qq, define */
+/*jshint strict:false,bitwise:false,nonew:false,asi:true,-W064,-W116,-W089 */
+/**
+ * Mega pixel image rendering library for iOS6+
+ *
+ * Fixes iOS6+'s image file rendering issue for large size image (over mega-pixel),
+ * which causes unexpected subsampling when drawing it in canvas.
+ * By using this library, you can safely render the image with proper stretching.
+ *
+ * Copyright (c) 2012 Shinichi Tomita <shinichi.tomita@gmail.com>
+ * Released under the MIT license
+ *
+ * Heavily modified by Widen for Fine Uploader
+ */
+(function() {
+
+    /**
+     * Detect subsampling in loaded image.
+     * In iOS, larger images than 2M pixels may be subsampled in rendering.
+     */
+    function detectSubsampling(img) {
+        var iw = img.naturalWidth,
+            ih = img.naturalHeight,
+            canvas = document.createElement("canvas"),
+            ctx;
+
+        if (iw * ih > 1024 * 1024) { // subsampling may happen over megapixel image
+            canvas.width = canvas.height = 1;
+            ctx = canvas.getContext("2d");
+            ctx.drawImage(img, -iw + 1, 0);
+            // subsampled image becomes half smaller in rendering size.
+            // check alpha channel value to confirm image is covering edge pixel or not.
+            // if alpha value is 0 image is not covering, hence subsampled.
+            return ctx.getImageData(0, 0, 1, 1).data[3] === 0;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Detecting vertical squash in loaded image.
+     * Fixes a bug which squash image vertically while drawing into canvas for some images.
+     */
+    function detectVerticalSquash(img, iw, ih) {
+        var canvas = document.createElement("canvas"),
+            sy = 0,
+            ey = ih,
+            py = ih,
+            ctx, data, alpha, ratio;
+
+        canvas.width = 1;
+        canvas.height = ih;
+        ctx = canvas.getContext("2d");
+        ctx.drawImage(img, 0, 0);
+        data = ctx.getImageData(0, 0, 1, ih).data;
+
+        // search image edge pixel position in case it is squashed vertically.
+        while (py > sy) {
+            alpha = data[(py - 1) * 4 + 3];
+            if (alpha === 0) {
+                ey = py;
+            } else {
+                sy = py;
+            }
+            py = (ey + sy) >> 1;
+        }
+
+        ratio = (py / ih);
+        return (ratio === 0) ? 1 : ratio;
+    }
+
+    /**
+     * Rendering image element (with resizing) and get its data URL
+     */
+    function renderImageToDataURL(img, options, doSquash) {
+        var canvas = document.createElement("canvas"),
+            mime = options.mime || "image/jpeg";
+
+        renderImageToCanvas(img, canvas, options, doSquash);
+        return canvas.toDataURL(mime, options.quality || 0.8);
+    }
+
+    function maybeCalculateDownsampledDimensions(spec) {
+        var maxPixels = 5241000; //iOS specific value
+
+        if (!qq.ios()) {
+            throw new qq.Error("Downsampled dimensions can only be reliably calculated for iOS!");
+        }
+
+        if (spec.origHeight * spec.origWidth > maxPixels) {
+            return {
+                newHeight: Math.round(Math.sqrt(maxPixels * (spec.origHeight / spec.origWidth))),
+                newWidth: Math.round(Math.sqrt(maxPixels * (spec.origWidth / spec.origHeight)))
+            }
+        }
+    }
+
+    /**
+     * Rendering image element (with resizing) into the canvas element
+     */
+    function renderImageToCanvas(img, canvas, options, doSquash) {
+        var iw = img.naturalWidth,
+            ih = img.naturalHeight,
+            width = options.width,
+            height = options.height,
+            ctx = canvas.getContext("2d"),
+            modifiedDimensions;
+
+        ctx.save();
+
+        if (!qq.supportedFeatures.unlimitedScaledImageSize) {
+            modifiedDimensions = maybeCalculateDownsampledDimensions({
+                origWidth: width,
+                origHeight: height
+            });
+
+            if (modifiedDimensions) {
+                qq.log(qq.format("Had to reduce dimensions due to device limitations from {}w / {}h to {}w / {}h",
+                    width, height, modifiedDimensions.newWidth, modifiedDimensions.newHeight),
+                "warn");
+
+                width = modifiedDimensions.newWidth;
+                height = modifiedDimensions.newHeight;
+            }
+        }
+
+        transformCoordinate(canvas, width, height, options.orientation);
+
+        // Fine Uploader specific: Save some CPU cycles if not using iOS
+        // Assumption: This logic is only needed to overcome iOS image sampling issues
+        if (qq.ios()) {
+            (function() {
+                if (detectSubsampling(img)) {
+                    iw /= 2;
+                    ih /= 2;
+                }
+
+                var d = 1024, // size of tiling canvas
+                    tmpCanvas = document.createElement("canvas"),
+                    vertSquashRatio = doSquash ? detectVerticalSquash(img, iw, ih) : 1,
+                    dw = Math.ceil(d * width / iw),
+                    dh = Math.ceil(d * height / ih / vertSquashRatio),
+                    sy = 0,
+                    dy = 0,
+                    tmpCtx, sx, dx;
+
+                tmpCanvas.width = tmpCanvas.height = d;
+                tmpCtx = tmpCanvas.getContext("2d");
+
+                while (sy < ih) {
+                    sx = 0,
+                    dx = 0;
+                    while (sx < iw) {
+                        tmpCtx.clearRect(0, 0, d, d);
+                        tmpCtx.drawImage(img, -sx, -sy);
+                        ctx.drawImage(tmpCanvas, 0, 0, d, d, dx, dy, dw, dh);
+                        sx += d;
+                        dx += dw;
+                    }
+                    sy += d;
+                    dy += dh;
+                }
+                ctx.restore();
+                tmpCanvas = tmpCtx = null;
+            }())
+        }
+        else {
+            ctx.drawImage(img, 0, 0, width, height);
+        }
+
+        canvas.qqImageRendered && canvas.qqImageRendered();
+    }
+
+    /**
+     * Transform canvas coordination according to specified frame size and orientation
+     * Orientation value is from EXIF tag
+     */
+    function transformCoordinate(canvas, width, height, orientation) {
+        switch (orientation) {
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+                canvas.width = height;
+                canvas.height = width;
+                break;
+            default:
+                canvas.width = width;
+                canvas.height = height;
+        }
+        var ctx = canvas.getContext("2d");
+        switch (orientation) {
+            case 2:
+                // horizontal flip
+                ctx.translate(width, 0);
+                ctx.scale(-1, 1);
+                break;
+            case 3:
+                // 180 rotate left
+                ctx.translate(width, height);
+                ctx.rotate(Math.PI);
+                break;
+            case 4:
+                // vertical flip
+                ctx.translate(0, height);
+                ctx.scale(1, -1);
+                break;
+            case 5:
+                // vertical flip + 90 rotate right
+                ctx.rotate(0.5 * Math.PI);
+                ctx.scale(1, -1);
+                break;
+            case 6:
+                // 90 rotate right
+                ctx.rotate(0.5 * Math.PI);
+                ctx.translate(0, -height);
+                break;
+            case 7:
+                // horizontal flip + 90 rotate right
+                ctx.rotate(0.5 * Math.PI);
+                ctx.translate(width, -height);
+                ctx.scale(-1, 1);
+                break;
+            case 8:
+                // 90 rotate left
+                ctx.rotate(-0.5 * Math.PI);
+                ctx.translate(-width, 0);
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * MegaPixImage class
+     */
+    function MegaPixImage(srcImage, errorCallback) {
+        var self = this;
+
+        if (window.Blob && srcImage instanceof Blob) {
+            (function() {
+                var img = new Image(),
+                    URL = window.URL && window.URL.createObjectURL ? window.URL :
+                        window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL : null;
+                if (!URL) { throw Error("No createObjectURL function found to create blob url"); }
+                img.src = URL.createObjectURL(srcImage);
+                self.blob = srcImage;
+                srcImage = img;
+            }());
+        }
+        if (!srcImage.naturalWidth && !srcImage.naturalHeight) {
+            srcImage.onload = function() {
+                var listeners = self.imageLoadListeners;
+                if (listeners) {
+                    self.imageLoadListeners = null;
+                    // IE11 doesn't reliably report actual image dimensions immediately after onload for small files,
+                    // so let's push this to the end of the UI thread queue.
+                    setTimeout(function() {
+                        for (var i = 0, len = listeners.length; i < len; i++) {
+                            listeners[i]();
+                        }
+                    }, 0);
+                }
+            };
+            srcImage.onerror = errorCallback;
+            this.imageLoadListeners = [];
+        }
+        this.srcImage = srcImage;
+    }
+
+    /**
+     * Rendering megapix image into specified target element
+     */
+    MegaPixImage.prototype.render = function(target, options) {
+        options = options || {};
+
+        var self = this,
+            imgWidth = this.srcImage.naturalWidth,
+            imgHeight = this.srcImage.naturalHeight,
+            width = options.width,
+            height = options.height,
+            maxWidth = options.maxWidth,
+            maxHeight = options.maxHeight,
+            doSquash = !this.blob || this.blob.type === "image/jpeg",
+            tagName = target.tagName.toLowerCase(),
+            opt;
+
+        if (this.imageLoadListeners) {
+            this.imageLoadListeners.push(function() { self.render(target, options) });
+            return;
+        }
+
+        if (width && !height) {
+            height = (imgHeight * width / imgWidth) << 0;
+        } else if (height && !width) {
+            width = (imgWidth * height / imgHeight) << 0;
+        } else {
+            width = imgWidth;
+            height = imgHeight;
+        }
+        if (maxWidth && width > maxWidth) {
+            width = maxWidth;
+            height = (imgHeight * width / imgWidth) << 0;
+        }
+        if (maxHeight && height > maxHeight) {
+            height = maxHeight;
+            width = (imgWidth * height / imgHeight) << 0;
+        }
+
+        opt = { width: width, height: height },
+        qq.each(options, function(optionsKey, optionsValue) {
+            opt[optionsKey] = optionsValue;
+        });
+
+        if (tagName === "img") {
+            (function() {
+                var oldTargetSrc = target.src;
+                target.src = renderImageToDataURL(self.srcImage, opt, doSquash);
+                oldTargetSrc === target.src && target.onload();
+            }())
+        } else if (tagName === "canvas") {
+            renderImageToCanvas(this.srcImage, target, opt, doSquash);
+        }
+        if (typeof this.onrender === "function") {
+            this.onrender(target);
+        }
+    };
+
+    qq.MegaPixImage = MegaPixImage;
+})();
+
+/*globals qq */
+/**
+ * Draws a thumbnail of a Blob/File/URL onto an <img> or <canvas>.
+ *
+ * @constructor
+ */
+qq.ImageGenerator = function(log) {
+    "use strict";
+
+    function isImg(el) {
+        return el.tagName.toLowerCase() === "img";
+    }
+
+    function isCanvas(el) {
+        return el.tagName.toLowerCase() === "canvas";
+    }
+
+    function isImgCorsSupported() {
+        return new Image().crossOrigin !== undefined;
+    }
+
+    function isCanvasSupported() {
+        var canvas = document.createElement("canvas");
+
+        return canvas.getContext && canvas.getContext("2d");
+    }
+
+    // This is only meant to determine the MIME type of a renderable image file.
+    // It is used to ensure images drawn from a URL that have transparent backgrounds
+    // are rendered correctly, among other things.
+    function determineMimeOfFileName(nameWithPath) {
+        /*jshint -W015 */
+        var pathSegments = nameWithPath.split("/"),
+            name = pathSegments[pathSegments.length - 1],
+            extension = qq.getExtension(name);
+
+        extension = extension && extension.toLowerCase();
+
+        switch (extension) {
+            case "jpeg":
+            case "jpg":
+                return "image/jpeg";
+            case "png":
+                return "image/png";
+            case "bmp":
+                return "image/bmp";
+            case "gif":
+                return "image/gif";
+            case "tiff":
+            case "tif":
+                return "image/tiff";
+        }
+    }
+
+    // This will likely not work correctly in IE8 and older.
+    // It's only used as part of a formula to determine
+    // if a canvas can be used to scale a server-hosted thumbnail.
+    // If canvas isn't supported by the UA (IE8 and older)
+    // this method should not even be called.
+    function isCrossOrigin(url) {
+        var targetAnchor = document.createElement("a"),
+            targetProtocol, targetHostname, targetPort;
+
+        targetAnchor.href = url;
+
+        targetProtocol = targetAnchor.protocol;
+        targetPort = targetAnchor.port;
+        targetHostname = targetAnchor.hostname;
+
+        if (targetProtocol.toLowerCase() !== window.location.protocol.toLowerCase()) {
+            return true;
+        }
+
+        if (targetHostname.toLowerCase() !== window.location.hostname.toLowerCase()) {
+            return true;
+        }
+
+        // IE doesn't take ports into consideration when determining if two endpoints are same origin.
+        if (targetPort !== window.location.port && !qq.ie()) {
+            return true;
+        }
+
+        return false;
+    }
+
+    function registerImgLoadListeners(img, promise) {
+        img.onload = function() {
+            img.onload = null;
+            img.onerror = null;
+            promise.success(img);
+        };
+
+        img.onerror = function() {
+            img.onload = null;
+            img.onerror = null;
+            log("Problem drawing thumbnail!", "error");
+            promise.failure(img, "Problem drawing thumbnail!");
+        };
+    }
+
+    function registerCanvasDrawImageListener(canvas, promise) {
+        // The image is drawn on the canvas by a third-party library,
+        // and we want to know when this is completed.  Since the library
+        // may invoke drawImage many times in a loop, we need to be called
+        // back when the image is fully rendered.  So, we are expecting the
+        // code that draws this image to follow a convention that involves a
+        // function attached to the canvas instance be invoked when it is done.
+        canvas.qqImageRendered = function() {
+            promise.success(canvas);
+        };
+    }
+
+    // Fulfills a `qq.Promise` when an image has been drawn onto the target,
+    // whether that is a <canvas> or an <img>.  The attempt is considered a
+    // failure if the target is not an <img> or a <canvas>, or if the drawing
+    // attempt was not successful.
+    function registerThumbnailRenderedListener(imgOrCanvas, promise) {
+        var registered = isImg(imgOrCanvas) || isCanvas(imgOrCanvas);
+
+        if (isImg(imgOrCanvas)) {
+            registerImgLoadListeners(imgOrCanvas, promise);
+        }
+        else if (isCanvas(imgOrCanvas)) {
+            registerCanvasDrawImageListener(imgOrCanvas, promise);
+        }
+        else {
+            promise.failure(imgOrCanvas);
+            log(qq.format("Element container of type {} is not supported!", imgOrCanvas.tagName), "error");
+        }
+
+        return registered;
+    }
+
+    // Draw a preview iff the current UA can natively display it.
+    // Also rotate the image if necessary.
+    function draw(fileOrBlob, container, options) {
+        var drawPreview = new qq.Promise(),
+            identifier = new qq.Identify(fileOrBlob, log),
+            maxSize = options.maxSize,
+            // jshint eqnull:true
+            orient = options.orient == null ? true : options.orient,
+            megapixErrorHandler = function() {
+                container.onerror = null;
+                container.onload = null;
+                log("Could not render preview, file may be too large!", "error");
+                drawPreview.failure(container, "Browser cannot render image!");
+            };
+
+        identifier.isPreviewable().then(
+            function(mime) {
+                // If options explicitly specify that Orientation is not desired,
+                // replace the orient task with a dummy promise that "succeeds" immediately.
+                var dummyExif = {
+                        parse: function() {
+                            return new qq.Promise().success();
+                        }
+                    },
+                    exif = orient ? new qq.Exif(fileOrBlob, log) : dummyExif,
+                    mpImg = new qq.MegaPixImage(fileOrBlob, megapixErrorHandler);
+
+                if (registerThumbnailRenderedListener(container, drawPreview)) {
+                    exif.parse().then(
+                        function(exif) {
+                            var orientation = exif && exif.Orientation;
+
+                            mpImg.render(container, {
+                                maxWidth: maxSize,
+                                maxHeight: maxSize,
+                                orientation: orientation,
+                                mime: mime
+                            });
+                        },
+
+                        function(failureMsg) {
+                            log(qq.format("EXIF data could not be parsed ({}).  Assuming orientation = 1.", failureMsg));
+
+                            mpImg.render(container, {
+                                maxWidth: maxSize,
+                                maxHeight: maxSize,
+                                mime: mime
+                            });
+                        }
+                    );
+                }
+            },
+
+            function() {
+                log("Not previewable");
+                drawPreview.failure(container, "Not previewable");
+            }
+        );
+
+        return drawPreview;
+    }
+
+    function drawOnCanvasOrImgFromUrl(url, canvasOrImg, draw, maxSize) {
+        var tempImg = new Image(),
+            tempImgRender = new qq.Promise();
+
+        registerThumbnailRenderedListener(tempImg, tempImgRender);
+
+        if (isCrossOrigin(url)) {
+            tempImg.crossOrigin = "anonymous";
+        }
+
+        tempImg.src = url;
+
+        tempImgRender.then(
+            function rendered() {
+                registerThumbnailRenderedListener(canvasOrImg, draw);
+
+                var mpImg = new qq.MegaPixImage(tempImg);
+                mpImg.render(canvasOrImg, {
+                    maxWidth: maxSize,
+                    maxHeight: maxSize,
+                    mime: determineMimeOfFileName(url)
+                });
+            },
+
+            draw.failure
+        );
+    }
+
+    function drawOnImgFromUrlWithCssScaling(url, img, draw, maxSize) {
+        registerThumbnailRenderedListener(img, draw);
+        // NOTE: The fact that maxWidth/height is set on the thumbnail for scaled images
+        // that must drop back to CSS is known and exploited by the templating module.
+        // In this module, we pre-render "waiting" thumbs for all files immediately after they
+        // are submitted, and we must be sure to pass any style associated with the "waiting" preview.
+        qq(img).css({
+            maxWidth: maxSize + "px",
+            maxHeight: maxSize + "px"
+        });
+
+        img.src = url;
+    }
+
+    // Draw a (server-hosted) thumbnail given a URL.
+    // This will optionally scale the thumbnail as well.
+    // It attempts to use <canvas> to scale, but will fall back
+    // to max-width and max-height style properties if the UA
+    // doesn't support canvas or if the images is cross-domain and
+    // the UA doesn't support the crossorigin attribute on img tags,
+    // which is required to scale a cross-origin image using <canvas> &
+    // then export it back to an <img>.
+    function drawFromUrl(url, container, options) {
+        var draw = new qq.Promise(),
+            scale = options.scale,
+            maxSize = scale ? options.maxSize : null;
+
+        // container is an img, scaling needed
+        if (scale && isImg(container)) {
+            // Iff canvas is available in this UA, try to use it for scaling.
+            // Otherwise, fall back to CSS scaling
+            if (isCanvasSupported()) {
+                // Attempt to use <canvas> for image scaling,
+                // but we must fall back to scaling via CSS/styles
+                // if this is a cross-origin image and the UA doesn't support <img> CORS.
+                if (isCrossOrigin(url) && !isImgCorsSupported()) {
+                    drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);
+                }
+                else {
+                    drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);
+                }
+            }
+            else {
+                drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);
+            }
+        }
+        // container is a canvas, scaling optional
+        else if (isCanvas(container)) {
+            drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);
+        }
+        // container is an img & no scaling: just set the src attr to the passed url
+        else if (registerThumbnailRenderedListener(container, draw)) {
+            container.src = url;
+        }
+
+        return draw;
+    }
+
+    qq.extend(this, {
+        /**
+         * Generate a thumbnail.  Depending on the arguments, this may either result in
+         * a client-side rendering of an image (if a `Blob` is supplied) or a server-generated
+         * image that may optionally be scaled client-side using <canvas> or CSS/styles (as a fallback).
+         *
+         * @param fileBlobOrUrl a `File`, `Blob`, or a URL pointing to the image
+         * @param container <img> or <canvas> to contain the preview
+         * @param options possible properties include `maxSize` (int), `orient` (bool - default true), and `resize` (bool - default true)
+         * @returns qq.Promise fulfilled when the preview has been drawn, or the attempt has failed
+         */
+        generate: function(fileBlobOrUrl, container, options) {
+            if (qq.isString(fileBlobOrUrl)) {
+                log("Attempting to update thumbnail based on server response.");
+                return drawFromUrl(fileBlobOrUrl, container, options || {});
+            }
+            else {
+                log("Attempting to draw client-side image preview.");
+                return draw(fileBlobOrUrl, container, options || {});
+            }
+        }
+    });
+
+};
+
+/*globals qq */
+/**
+ * EXIF image data parser.  Currently only parses the Orientation tag value,
+ * but this may be expanded to other tags in the future.
+ *
+ * @param fileOrBlob Attempt to parse EXIF data in this `Blob`
+ * @constructor
+ */
+qq.Exif = function(fileOrBlob, log) {
+    "use strict";
+
+    // Orientation is the only tag parsed here at this time.
+    var TAG_IDS = [274],
+        TAG_INFO = {
+            274: {
+                name: "Orientation",
+                bytes: 2
+            }
+        };
+
+    // Convert a little endian (hex string) to big endian (decimal).
+    function parseLittleEndian(hex) {
+        var result = 0,
+            pow = 0;
+
+        while (hex.length > 0) {
+            result += parseInt(hex.substring(0, 2), 16) * Math.pow(2, pow);
+            hex = hex.substring(2, hex.length);
+            pow += 8;
+        }
+
+        return result;
+    }
+
+    // Find the byte offset, of Application Segment 1 (EXIF).
+    // External callers need not supply any arguments.
+    function seekToApp1(offset, promise) {
+        var theOffset = offset,
+            thePromise = promise;
+        if (theOffset === undefined) {
+            theOffset = 2;
+            thePromise = new qq.Promise();
+        }
+
+        qq.readBlobToHex(fileOrBlob, theOffset, 4).then(function(hex) {
+            var match = /^ffe([0-9])/.exec(hex),
+                segmentLength;
+
+            if (match) {
+                if (match[1] !== "1") {
+                    segmentLength = parseInt(hex.slice(4, 8), 16);
+                    seekToApp1(theOffset + segmentLength + 2, thePromise);
+                }
+                else {
+                    thePromise.success(theOffset);
+                }
+            }
+            else {
+                thePromise.failure("No EXIF header to be found!");
+            }
+        });
+
+        return thePromise;
+    }
+
+    // Find the byte offset of Application Segment 1 (EXIF) for valid JPEGs only.
+    function getApp1Offset() {
+        var promise = new qq.Promise();
+
+        qq.readBlobToHex(fileOrBlob, 0, 6).then(function(hex) {
+            if (hex.indexOf("ffd8") !== 0) {
+                promise.failure("Not a valid JPEG!");
+            }
+            else {
+                seekToApp1().then(function(offset) {
+                    promise.success(offset);
+                },
+                function(error) {
+                    promise.failure(error);
+                });
+            }
+        });
+
+        return promise;
+    }
+
+    // Determine the byte ordering of the EXIF header.
+    function isLittleEndian(app1Start) {
+        var promise = new qq.Promise();
+
+        qq.readBlobToHex(fileOrBlob, app1Start + 10, 2).then(function(hex) {
+            promise.success(hex === "4949");
+        });
+
+        return promise;
+    }
+
+    // Determine the number of directory entries in the EXIF header.
+    function getDirEntryCount(app1Start, littleEndian) {
+        var promise = new qq.Promise();
+
+        qq.readBlobToHex(fileOrBlob, app1Start + 18, 2).then(function(hex) {
+            if (littleEndian) {
+                return promise.success(parseLittleEndian(hex));
+            }
+            else {
+                promise.success(parseInt(hex, 16));
+            }
+        });
+
+        return promise;
+    }
+
+    // Get the IFD portion of the EXIF header as a hex string.
+    function getIfd(app1Start, dirEntries) {
+        var offset = app1Start + 20,
+            bytes = dirEntries * 12;
+
+        return qq.readBlobToHex(fileOrBlob, offset, bytes);
+    }
+
+    // Obtain an array of all directory entries (as hex strings) in the EXIF header.
+    function getDirEntries(ifdHex) {
+        var entries = [],
+            offset = 0;
+
+        while (offset + 24 <= ifdHex.length) {
+            entries.push(ifdHex.slice(offset, offset + 24));
+            offset += 24;
+        }
+
+        return entries;
+    }
+
+    // Obtain values for all relevant tags and return them.
+    function getTagValues(littleEndian, dirEntries) {
+        var TAG_VAL_OFFSET = 16,
+            tagsToFind = qq.extend([], TAG_IDS),
+            vals = {};
+
+        qq.each(dirEntries, function(idx, entry) {
+            var idHex = entry.slice(0, 4),
+                id = littleEndian ? parseLittleEndian(idHex) : parseInt(idHex, 16),
+                tagsToFindIdx = tagsToFind.indexOf(id),
+                tagValHex, tagName, tagValLength;
+
+            if (tagsToFindIdx >= 0) {
+                tagName = TAG_INFO[id].name;
+                tagValLength = TAG_INFO[id].bytes;
+                tagValHex = entry.slice(TAG_VAL_OFFSET, TAG_VAL_OFFSET + (tagValLength * 2));
+                vals[tagName] = littleEndian ? parseLittleEndian(tagValHex) : parseInt(tagValHex, 16);
+
+                tagsToFind.splice(tagsToFindIdx, 1);
+            }
+
+            if (tagsToFind.length === 0) {
+                return false;
+            }
+        });
+
+        return vals;
+    }
+
+    qq.extend(this, {
+        /**
+         * Attempt to parse the EXIF header for the `Blob` associated with this instance.
+         *
+         * @returns {qq.Promise} To be fulfilled when the parsing is complete.
+         * If successful, the parsed EXIF header as an object will be included.
+         */
+        parse: function() {
+            var parser = new qq.Promise(),
+                onParseFailure = function(message) {
+                    log(qq.format("EXIF header parse failed: '{}' ", message));
+                    parser.failure(message);
+                };
+
+            getApp1Offset().then(function(app1Offset) {
+                log(qq.format("Moving forward with EXIF header parsing for '{}'", fileOrBlob.name === undefined ? "blob" : fileOrBlob.name));
+
+                isLittleEndian(app1Offset).then(function(littleEndian) {
+
+                    log(qq.format("EXIF Byte order is {} endian", littleEndian ? "little" : "big"));
+
+                    getDirEntryCount(app1Offset, littleEndian).then(function(dirEntryCount) {
+
+                        log(qq.format("Found {} APP1 directory entries", dirEntryCount));
+
+                        getIfd(app1Offset, dirEntryCount).then(function(ifdHex) {
+                            var dirEntries = getDirEntries(ifdHex),
+                                tagValues = getTagValues(littleEndian, dirEntries);
+
+                            log("Successfully parsed some EXIF tags");
+
+                            parser.success(tagValues);
+                        }, onParseFailure);
+                    }, onParseFailure);
+                }, onParseFailure);
+            }, onParseFailure);
+
+            return parser;
+        }
+    });
+
+};
+
+/*globals qq */
+qq.Identify = function(fileOrBlob, log) {
+    "use strict";
+
+    function isIdentifiable(magicBytes, questionableBytes) {
+        var identifiable = false,
+            magicBytesEntries = [].concat(magicBytes);
+
+        qq.each(magicBytesEntries, function(idx, magicBytesArrayEntry) {
+            if (questionableBytes.indexOf(magicBytesArrayEntry) === 0) {
+                identifiable = true;
+                return false;
+            }
+        });
+
+        return identifiable;
+    }
+
+    qq.extend(this, {
+        /**
+         * Determines if a Blob can be displayed natively in the current browser.  This is done by reading magic
+         * bytes in the beginning of the file, so this is an asynchronous operation.  Before we attempt to read the
+         * file, we will examine the blob's type attribute to save CPU cycles.
+         *
+         * @returns {qq.Promise} Promise that is fulfilled when identification is complete.
+         * If successful, the MIME string is passed to the success handler.
+         */
+        isPreviewable: function() {
+            var self = this,
+                idenitifer = new qq.Promise(),
+                previewable = false,
+                name = fileOrBlob.name === undefined ? "blob" : fileOrBlob.name;
+
+            log(qq.format("Attempting to determine if {} can be rendered in this browser", name));
+
+            log("First pass: check type attribute of blob object.");
+
+            if (this.isPreviewableSync()) {
+                log("Second pass: check for magic bytes in file header.");
+
+                qq.readBlobToHex(fileOrBlob, 0, 4).then(function(hex) {
+                    qq.each(self.PREVIEWABLE_MIME_TYPES, function(mime, bytes) {
+                        if (isIdentifiable(bytes, hex)) {
+                            // Safari is the only supported browser that can deal with TIFFs natively,
+                            // so, if this is a TIFF and the UA isn't Safari, declare this file "non-previewable".
+                            if (mime !== "image/tiff" || qq.supportedFeatures.tiffPreviews) {
+                                previewable = true;
+                                idenitifer.success(mime);
+                            }
+
+                            return false;
+                        }
+                    });
+
+                    log(qq.format("'{}' is {} able to be rendered in this browser", name, previewable ? "" : "NOT"));
+
+                    if (!previewable) {
+                        idenitifer.failure();
+                    }
+                },
+                function() {
+                    log("Error reading file w/ name '" + name + "'.  Not able to be rendered in this browser.");
+                    idenitifer.failure();
+                });
+            }
+            else {
+                idenitifer.failure();
+            }
+
+            return idenitifer;
+        },
+
+        /**
+         * Determines if a Blob can be displayed natively in the current browser.  This is done by checking the
+         * blob's type attribute.  This is a synchronous operation, useful for situations where an asynchronous operation
+         * would be challenging to support.  Note that the blob's type property is not as accurate as reading the
+         * file's magic bytes.
+         *
+         * @returns {Boolean} true if the blob can be rendered in the current browser
+         */
+        isPreviewableSync: function() {
+            var fileMime = fileOrBlob.type,
+                // Assumption: This will only ever be executed in browsers that support `Object.keys`.
+                isRecognizedImage = qq.indexOf(Object.keys(this.PREVIEWABLE_MIME_TYPES), fileMime) >= 0,
+                previewable = false,
+                name = fileOrBlob.name === undefined ? "blob" : fileOrBlob.name;
+
+            if (isRecognizedImage) {
+                if (fileMime === "image/tiff") {
+                    previewable = qq.supportedFeatures.tiffPreviews;
+                }
+                else {
+                    previewable = true;
+                }
+            }
+
+            !previewable && log(name + " is not previewable in this browser per the blob's type attr");
+
+            return previewable;
+        }
+    });
+};
+
+qq.Identify.prototype.PREVIEWABLE_MIME_TYPES = {
+    "image/jpeg": "ffd8ff",
+    "image/gif": "474946",
+    "image/png": "89504e",
+    "image/bmp": "424d",
+    "image/tiff": ["49492a00", "4d4d002a"]
+};
+
+/*globals qq*/
+/**
+ * Attempts to validate an image, wherever possible.
+ *
+ * @param blob File or Blob representing a user-selecting image.
+ * @param log Uses this to post log messages to the console.
+ * @constructor
+ */
+qq.ImageValidation = function(blob, log) {
+    "use strict";
+
+    /**
+     * @param limits Object with possible image-related limits to enforce.
+     * @returns {boolean} true if at least one of the limits has a non-zero value
+     */
+    function hasNonZeroLimits(limits) {
+        var atLeastOne = false;
+
+        qq.each(limits, function(limit, value) {
+            if (value > 0) {
+                atLeastOne = true;
+                return false;
+            }
+        });
+
+        return atLeastOne;
+    }
+
+    /**
+     * @returns {qq.Promise} The promise is a failure if we can't obtain the width & height.
+     * Otherwise, `success` is called on the returned promise with an object containing
+     * `width` and `height` properties.
+     */
+    function getWidthHeight() {
+        var sizeDetermination = new qq.Promise();
+
+        new qq.Identify(blob, log).isPreviewable().then(function() {
+            var image = new Image(),
+                url = window.URL && window.URL.createObjectURL ? window.URL :
+                      window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL :
+                      null;
+
+            if (url) {
+                image.onerror = function() {
+                    log("Cannot determine dimensions for image.  May be too large.", "error");
+                    sizeDetermination.failure();
+                };
+
+                image.onload = function() {
+                    sizeDetermination.success({
+                        width: this.width,
+                        height: this.height
+                    });
+                };
+
+                image.src = url.createObjectURL(blob);
+            }
+            else {
+                log("No createObjectURL function available to generate image URL!", "error");
+                sizeDetermination.failure();
+            }
+        }, sizeDetermination.failure);
+
+        return sizeDetermination;
+    }
+
+    /**
+     *
+     * @param limits Object with possible image-related limits to enforce.
+     * @param dimensions Object containing `width` & `height` properties for the image to test.
+     * @returns {String || undefined} The name of the failing limit.  Undefined if no failing limits.
+     */
+    function getFailingLimit(limits, dimensions) {
+        var failingLimit;
+
+        qq.each(limits, function(limitName, limitValue) {
+            if (limitValue > 0) {
+                var limitMatcher = /(max|min)(Width|Height)/.exec(limitName),
+                    dimensionPropName = limitMatcher[2].charAt(0).toLowerCase() + limitMatcher[2].slice(1),
+                    actualValue = dimensions[dimensionPropName];
+
+                /*jshint -W015*/
+                switch (limitMatcher[1]) {
+                    case "min":
+                        if (actualValue < limitValue) {
+                            failingLimit = limitName;
+                            return false;
+                        }
+                        break;
+                    case "max":
+                        if (actualValue > limitValue) {
+                            failingLimit = limitName;
+                            return false;
+                        }
+                        break;
+                }
+            }
+        });
+
+        return failingLimit;
+    }
+
+    /**
+     * Validate the associated blob.
+     *
+     * @param limits
+     * @returns {qq.Promise} `success` is called on the promise is the image is valid or
+     * if the blob is not an image, or if the image is not verifiable.
+     * Otherwise, `failure` with the name of the failing limit.
+     */
+    this.validate = function(limits) {
+        var validationEffort = new qq.Promise();
+
+        log("Attempting to validate image.");
+
+        if (hasNonZeroLimits(limits)) {
+            getWidthHeight().then(function(dimensions) {
+                var failingLimit = getFailingLimit(limits, dimensions);
+
+                if (failingLimit) {
+                    validationEffort.failure(failingLimit);
+                }
+                else {
+                    validationEffort.success();
+                }
+            }, validationEffort.success);
+        }
+        else {
+            validationEffort.success();
+        }
+
+        return validationEffort;
+    };
+};
+
+/* globals qq */
+/**
+ * Module used to control populating the initial list of files.
+ *
+ * @constructor
+ */
+qq.Session = function(spec) {
+    "use strict";
+
+    var options = {
+        endpoint: null,
+        params: {},
+        customHeaders: {},
+        cors: {},
+        addFileRecord: function(sessionData) {},
+        log: function(message, level) {}
+    };
+
+    qq.extend(options, spec, true);
+
+    function isJsonResponseValid(response) {
+        if (qq.isArray(response)) {
+            return true;
+        }
+
+        options.log("Session response is not an array.", "error");
+    }
+
+    function handleFileItems(fileItems, success, xhrOrXdr, promise) {
+        var someItemsIgnored = false;
+
+        success = success && isJsonResponseValid(fileItems);
+
+        if (success) {
+            qq.each(fileItems, function(idx, fileItem) {
+                /* jshint eqnull:true */
+                if (fileItem.uuid == null) {
+                    someItemsIgnored = true;
+                    options.log(qq.format("Session response item {} did not include a valid UUID - ignoring.", idx), "error");
+                }
+                else if (fileItem.name == null) {
+                    someItemsIgnored = true;
+                    options.log(qq.format("Session response item {} did not include a valid name - ignoring.", idx), "error");
+                }
+                else {
+                    try {
+                        options.addFileRecord(fileItem);
+                        return true;
+                    }
+                    catch (err) {
+                        someItemsIgnored = true;
+                        options.log(err.message, "error");
+                    }
+                }
+
+                return false;
+            });
+        }
+
+        promise[success && !someItemsIgnored ? "success" : "failure"](fileItems, xhrOrXdr);
+    }
+
+    // Initiate a call to the server that will be used to populate the initial file list.
+    // Returns a `qq.Promise`.
+    this.refresh = function() {
+        /*jshint indent:false */
+        var refreshEffort = new qq.Promise(),
+            refreshCompleteCallback = function(response, success, xhrOrXdr) {
+                handleFileItems(response, success, xhrOrXdr, refreshEffort);
+            },
+            requsterOptions = qq.extend({}, options),
+            requester = new qq.SessionAjaxRequester(
+                qq.extend(requsterOptions, {onComplete: refreshCompleteCallback})
+            );
+
+        requester.queryServer();
+
+        return refreshEffort;
+    };
+};
+
+/*globals qq, XMLHttpRequest*/
+/**
+ * Thin module used to send GET requests to the server, expecting information about session
+ * data used to initialize an uploader instance.
+ *
+ * @param spec Various options used to influence the associated request.
+ * @constructor
+ */
+qq.SessionAjaxRequester = function(spec) {
+    "use strict";
+
+    var requester,
+        options = {
+            endpoint: null,
+            customHeaders: {},
+            params: {},
+            cors: {
+                expected: false,
+                sendCredentials: false
+            },
+            onComplete: function(response, success, xhrOrXdr) {},
+            log: function(str, level) {}
+        };
+
+    qq.extend(options, spec);
+
+    function onComplete(id, xhrOrXdr, isError) {
+        var response = null;
+
+        /* jshint eqnull:true */
+        if (xhrOrXdr.responseText != null) {
+            try {
+                response = qq.parseJson(xhrOrXdr.responseText);
+            }
+            catch (err) {
+                options.log("Problem parsing session response: " + err.message, "error");
+                isError = true;
+            }
+        }
+
+        options.onComplete(response, !isError, xhrOrXdr);
+    }
+
+    requester = qq.extend(this, new qq.AjaxRequester({
+        acceptHeader: "application/json",
+        validMethods: ["GET"],
+        method: "GET",
+        endpointStore: {
+            get: function() {
+                return options.endpoint;
+            }
+        },
+        customHeaders: options.customHeaders,
+        log: options.log,
+        onComplete: onComplete,
+        cors: options.cors
+    }));
+
+    qq.extend(this, {
+        queryServer: function() {
+            var params = qq.extend({}, options.params);
+
+            options.log("Session query request.");
+
+            requester.initTransport("sessionRefresh")
+                .withParams(params)
+                .withCacheBuster()
+                .send();
+        }
+    });
+};
+
+/* globals qq */
+/**
+ * Module that handles support for existing forms.
+ *
+ * @param options Options passed from the integrator-supplied options related to form support.
+ * @param startUpload Callback to invoke when files "stored" should be uploaded.
+ * @param log Proxy for the logger
+ * @constructor
+ */
+qq.FormSupport = function(options, startUpload, log) {
+    "use strict";
+    var self  = this,
+        interceptSubmit = options.interceptSubmit,
+        formEl = options.element,
+        autoUpload = options.autoUpload;
+
+    // Available on the public API associated with this module.
+    qq.extend(this, {
+        // To be used by the caller to determine if the endpoint will be determined by some processing
+        // that occurs in this module, such as if the form has an action attribute.
+        // Ignore if `attachToForm === false`.
+        newEndpoint: null,
+
+        // To be used by the caller to determine if auto uploading should be allowed.
+        // Ignore if `attachToForm === false`.
+        newAutoUpload: autoUpload,
+
+        // true if a form was detected and is being tracked by this module
+        attachedToForm: false,
+
+        // Returns an object with names and values for all valid form elements associated with the attached form.
+        getFormInputsAsObject: function() {
+            /* jshint eqnull:true */
+            if (formEl == null) {
+                return null;
+            }
+
+            return self._form2Obj(formEl);
+        }
+    });
+
+    // If the form contains an action attribute, this should be the new upload endpoint.
+    function determineNewEndpoint(formEl) {
+        if (formEl.getAttribute("action")) {
+            self.newEndpoint = formEl.getAttribute("action");
+        }
+    }
+
+    // Return true only if the form is valid, or if we cannot make this determination.
+    // If the form is invalid, ensure invalid field(s) are highlighted in the UI.
+    function validateForm(formEl, nativeSubmit) {
+        if (formEl.checkValidity && !formEl.checkValidity()) {
+            log("Form did not pass validation checks - will not upload.", "error");
+            nativeSubmit();
+        }
+        else {
+            return true;
+        }
+    }
+
+    // Intercept form submit attempts, unless the integrator has told us not to do this.
+    function maybeUploadOnSubmit(formEl) {
+        var nativeSubmit = formEl.submit;
+
+        // Intercept and squelch submit events.
+        qq(formEl).attach("submit", function(event) {
+            event = event || window.event;
+
+            if (event.preventDefault) {
+                event.preventDefault();
+            }
+            else {
+                event.returnValue = false;
+            }
+
+            validateForm(formEl, nativeSubmit) && startUpload();
+        });
+
+        // The form's `submit()` function may be called instead (i.e. via jQuery.submit()).
+        // Intercept that too.
+        formEl.submit = function() {
+            validateForm(formEl, nativeSubmit) && startUpload();
+        };
+    }
+
+    // If the element value passed from the uploader is a string, assume it is an element ID - select it.
+    // The rest of the code in this module depends on this being an HTMLElement.
+    function determineFormEl(formEl) {
+        if (formEl) {
+            if (qq.isString(formEl)) {
+                formEl = document.getElementById(formEl);
+            }
+
+            if (formEl) {
+                log("Attaching to form element.");
+                determineNewEndpoint(formEl);
+                interceptSubmit && maybeUploadOnSubmit(formEl);
+            }
+        }
+
+        return formEl;
+    }
+
+    formEl = determineFormEl(formEl);
+    this.attachedToForm = !!formEl;
+};
+
+qq.extend(qq.FormSupport.prototype, {
+    // Converts all relevant form fields to key/value pairs.  This is meant to mimic the data a browser will
+    // construct from a given form when the form is submitted.
+    _form2Obj: function(form) {
+        "use strict";
+        var obj = {},
+            notIrrelevantType = function(type) {
+                var irrelevantTypes = [
+                    "button",
+                    "image",
+                    "reset",
+                    "submit"
+                ];
+
+                return qq.indexOf(irrelevantTypes, type.toLowerCase()) < 0;
+            },
+            radioOrCheckbox = function(type) {
+                return qq.indexOf(["checkbox", "radio"], type.toLowerCase()) >= 0;
+            },
+            ignoreValue = function(el) {
+                if (radioOrCheckbox(el.type) && !el.checked) {
+                    return true;
+                }
+
+                return el.disabled && el.type.toLowerCase() !== "hidden";
+            },
+            selectValue = function(select) {
+                var value = null;
+
+                qq.each(qq(select).children(), function(idx, child) {
+                    if (child.tagName.toLowerCase() === "option" && child.selected) {
+                        value = child.value;
+                        return false;
+                    }
+                });
+
+                return value;
+            };
+
+        qq.each(form.elements, function(idx, el) {
+            if ((qq.isInput(el, true) || el.tagName.toLowerCase() === "textarea") &&
+                notIrrelevantType(el.type) &&
+                !ignoreValue(el)) {
+
+                obj[el.name] = el.value;
+            }
+            else if (el.tagName.toLowerCase() === "select" && !ignoreValue(el)) {
+                var value = selectValue(el);
+
+                if (value !== null) {
+                    obj[el.name] = value;
+                }
+            }
+        });
+
+        return obj;
+    }
+});
+
+/* globals qq, ExifRestorer */
+/**
+ * Controls generation of scaled images based on a reference image encapsulated in a `File` or `Blob`.
+ * Scaled images are generated and converted to blobs on-demand.
+ * Multiple scaled images per reference image with varying sizes and other properties are supported.
+ *
+ * @param spec Information about the scaled images to generate.
+ * @param log Logger instance
+ * @constructor
+ */
+qq.Scaler = function(spec, log) {
+    "use strict";
+
+    var self = this,
+        includeReference = spec.sendOriginal,
+        orient = spec.orient,
+        defaultType = spec.defaultType,
+        defaultQuality = spec.defaultQuality / 100,
+        failedToScaleText = spec.failureText,
+        includeExif = spec.includeExif,
+        sizes = this._getSortedSizes(spec.sizes);
+
+    // Revealed API for instances of this module
+    qq.extend(this, {
+        // If no targeted sizes have been declared or if this browser doesn't support
+        // client-side image preview generation, there is no scaling to do.
+        enabled: qq.supportedFeatures.scaling && sizes.length > 0,
+
+        getFileRecords: function(originalFileUuid, originalFileName, originalBlobOrBlobData) {
+            var self = this,
+                records = [],
+                originalBlob = originalBlobOrBlobData.blob ? originalBlobOrBlobData.blob : originalBlobOrBlobData,
+                idenitifier = new qq.Identify(originalBlob, log);
+
+            // If the reference file cannot be rendered natively, we can't create scaled versions.
+            if (idenitifier.isPreviewableSync()) {
+                // Create records for each scaled version & add them to the records array, smallest first.
+                qq.each(sizes, function(idx, sizeRecord) {
+                    var outputType = self._determineOutputType({
+                        defaultType: defaultType,
+                        requestedType: sizeRecord.type,
+                        refType: originalBlob.type
+                    });
+
+                    records.push({
+                        uuid: qq.getUniqueId(),
+                        name: self._getName(originalFileName, {
+                            name: sizeRecord.name,
+                            type: outputType,
+                            refType: originalBlob.type
+                        }),
+                        blob: new qq.BlobProxy(originalBlob,
+                        qq.bind(self._generateScaledImage, self, {
+                            maxSize: sizeRecord.maxSize,
+                            orient: orient,
+                            type: outputType,
+                            quality: defaultQuality,
+                            failedText: failedToScaleText,
+                            includeExif: includeExif,
+                            log: log
+                        }))
+                    });
+                });
+
+                includeReference && records.push({
+                    uuid: originalFileUuid,
+                    name: originalFileName,
+                    blob: originalBlob
+                });
+            }
+            else {
+                records.push({
+                    uuid: originalFileUuid,
+                    name: originalFileName,
+                    blob: originalBlob
+                });
+            }
+
+            return records;
+        },
+
+        handleNewFile: function(file, name, uuid, size, fileList, batchId, uuidParamName, api) {
+            var self = this,
+                buttonId = file.qqButtonId || (file.blob && file.blob.qqButtonId),
+                scaledIds = [],
+                originalId = null,
+                addFileToHandler = api.addFileToHandler,
+                uploadData = api.uploadData,
+                paramsStore = api.paramsStore,
+                proxyGroupId = qq.getUniqueId();
+
+            qq.each(self.getFileRecords(uuid, name, file), function(idx, record) {
+                var relatedBlob = file,
+                    relatedSize = size,
+                    id;
+
+                if (record.blob instanceof qq.BlobProxy) {
+                    relatedBlob = record.blob;
+                    relatedSize = -1;
+                }
+
+                id = uploadData.addFile({
+                    uuid: record.uuid,
+                    name: record.name,
+                    size: relatedSize,
+                    batchId: batchId,
+                    proxyGroupId: proxyGroupId
+                });
+
+                if (record.blob instanceof qq.BlobProxy) {
+                    scaledIds.push(id);
+                }
+                else {
+                    originalId = id;
+                }
+
+                addFileToHandler(id, relatedBlob);
+
+                fileList.push({id: id, file: relatedBlob});
+
+            });
+
+            // If we are potentially uploading an original file and some scaled versions,
+            // ensure the scaled versions include reference's to the parent's UUID and size
+            // in their associated upload requests.
+            if (originalId !== null) {
+                qq.each(scaledIds, function(idx, scaledId) {
+                    var params = {
+                        qqparentuuid: uploadData.retrieve({id: originalId}).uuid,
+                        qqparentsize: uploadData.retrieve({id: originalId}).size
+                    };
+
+                    // Make SURE the UUID for each scaled image is sent with the upload request,
+                    // to be consistent (since we need to ensure it is sent for the original file as well).
+                    params[uuidParamName] = uploadData.retrieve({id: scaledId}).uuid;
+
+                    uploadData.setParentId(scaledId, originalId);
+                    paramsStore.addReadOnly(scaledId, params);
+                });
+
+                // If any scaled images are tied to this parent image, be SURE we send its UUID as an upload request
+                // parameter as well.
+                if (scaledIds.length) {
+                    (function() {
+                        var param = {};
+                        param[uuidParamName] = uploadData.retrieve({id: originalId}).uuid;
+                        paramsStore.addReadOnly(originalId, param);
+                    }());
+                }
+            }
+        }
+    });
+};
+
+qq.extend(qq.Scaler.prototype, {
+    scaleImage: function(id, specs, api) {
+        "use strict";
+
+        if (!qq.supportedFeatures.scaling) {
+            throw new qq.Error("Scaling is not supported in this browser!");
+        }
+
+        var scalingEffort = new qq.Promise(),
+            log = api.log,
+            file = api.getFile(id),
+            uploadData = api.uploadData.retrieve({id: id}),
+            name = uploadData && uploadData.name,
+            uuid = uploadData && uploadData.uuid,
+            scalingOptions = {
+                sendOriginal: false,
+                orient: specs.orient,
+                defaultType: specs.type || null,
+                defaultQuality: specs.quality,
+                failedToScaleText: "Unable to scale",
+                sizes: [{name: "", maxSize: specs.maxSize}]
+            },
+            scaler = new qq.Scaler(scalingOptions, log);
+
+        if (!qq.Scaler || !qq.supportedFeatures.imagePreviews || !file) {
+            scalingEffort.failure();
+
+            log("Could not generate requested scaled image for " + id + ".  " +
+                "Scaling is either not possible in this browser, or the file could not be located.", "error");
+        }
+        else {
+            (qq.bind(function() {
+                // Assumption: There will never be more than one record
+                var record = scaler.getFileRecords(uuid, name, file)[0];
+
+                if (record && record.blob instanceof qq.BlobProxy) {
+                    record.blob.create().then(scalingEffort.success, scalingEffort.failure);
+                }
+                else {
+                    log(id + " is not a scalable image!", "error");
+                    scalingEffort.failure();
+                }
+            }, this)());
+        }
+
+        return scalingEffort;
+    },
+
+    // NOTE: We cannot reliably determine at this time if the UA supports a specific MIME type for the target format.
+    // image/jpeg and image/png are the only safe choices at this time.
+    _determineOutputType: function(spec) {
+        "use strict";
+
+        var requestedType = spec.requestedType,
+            defaultType = spec.defaultType,
+            referenceType = spec.refType;
+
+        // If a default type and requested type have not been specified, this should be a
+        // JPEG if the original type is a JPEG, otherwise, a PNG.
+        if (!defaultType && !requestedType) {
+            if (referenceType !== "image/jpeg") {
+                return "image/png";
+            }
+            return referenceType;
+        }
+
+        // A specified default type is used when a requested type is not specified.
+        if (!requestedType) {
+            return defaultType;
+        }
+
+        // If requested type is specified, use it, as long as this recognized type is supported by the current UA
+        if (qq.indexOf(Object.keys(qq.Identify.prototype.PREVIEWABLE_MIME_TYPES), requestedType) >= 0) {
+            if (requestedType === "image/tiff") {
+                return qq.supportedFeatures.tiffPreviews ? requestedType : defaultType;
+            }
+
+            return requestedType;
+        }
+
+        return defaultType;
+    },
+
+    // Get a file name for a generated scaled file record, based on the provided scaled image description
+    _getName: function(originalName, scaledVersionProperties) {
+        "use strict";
+
+        var startOfExt = originalName.lastIndexOf("."),
+            versionType = scaledVersionProperties.type || "image/png",
+            referenceType = scaledVersionProperties.refType,
+            scaledName = "",
+            scaledExt = qq.getExtension(originalName),
+            nameAppendage = "";
+
+        if (scaledVersionProperties.name && scaledVersionProperties.name.trim().length) {
+            nameAppendage = " (" + scaledVersionProperties.name + ")";
+        }
+
+        if (startOfExt >= 0) {
+            scaledName = originalName.substr(0, startOfExt);
+
+            if (referenceType !== versionType) {
+                scaledExt = versionType.split("/")[1];
+            }
+
+            scaledName += nameAppendage + "." + scaledExt;
+        }
+        else {
+            scaledName = originalName + nameAppendage;
+        }
+
+        return scaledName;
+    },
+
+    // We want the smallest scaled file to be uploaded first
+    _getSortedSizes: function(sizes) {
+        "use strict";
+
+        sizes = qq.extend([], sizes);
+
+        return sizes.sort(function(a, b) {
+            if (a.maxSize > b.maxSize) {
+                return 1;
+            }
+            if (a.maxSize < b.maxSize) {
+                return -1;
+            }
+            return 0;
+        });
+    },
+
+    _generateScaledImage: function(spec, sourceFile) {
+        "use strict";
+
+        var self = this,
+            log = spec.log,
+            maxSize = spec.maxSize,
+            orient = spec.orient,
+            type = spec.type,
+            quality = spec.quality,
+            failedText = spec.failedText,
+            includeExif = spec.includeExif && sourceFile.type === "image/jpeg" && type === "image/jpeg",
+            scalingEffort = new qq.Promise(),
+            imageGenerator = new qq.ImageGenerator(log),
+            canvas = document.createElement("canvas");
+
+        log("Attempting to generate scaled version for " + sourceFile.name);
+
+        imageGenerator.generate(sourceFile, canvas, {maxSize: maxSize, orient: orient}).then(function() {
+            var scaledImageDataUri = canvas.toDataURL(type, quality),
+                signalSuccess = function() {
+                    log("Success generating scaled version for " + sourceFile.name);
+                    var blob = qq.dataUriToBlob(scaledImageDataUri);
+                    scalingEffort.success(blob);
+                };
+
+            if (includeExif) {
+                self._insertExifHeader(sourceFile, scaledImageDataUri, log).then(function(scaledImageDataUriWithExif) {
+                    scaledImageDataUri = scaledImageDataUriWithExif;
+                    signalSuccess();
+                },
+                function() {
+                    log("Problem inserting EXIF header into scaled image.  Using scaled image w/out EXIF data.", "error");
+                    signalSuccess();
+                });
+            }
+            else {
+                signalSuccess();
+            }
+        }, function() {
+            log("Failed attempt to generate scaled version for " + sourceFile.name, "error");
+            scalingEffort.failure(failedText);
+        });
+
+        return scalingEffort;
+    },
+
+    // Attempt to insert the original image's EXIF header into a scaled version.
+    _insertExifHeader: function(originalImage, scaledImageDataUri, log) {
+        "use strict";
+
+        var reader = new FileReader(),
+            insertionEffort = new qq.Promise(),
+            originalImageDataUri = "";
+
+        reader.onload = function() {
+            originalImageDataUri = reader.result;
+            insertionEffort.success(ExifRestorer.restore(originalImageDataUri, scaledImageDataUri));
+        };
+
+        reader.onerror = function() {
+            log("Problem reading " + originalImage.name + " during attempt to transfer EXIF data to scaled version.", "error");
+            insertionEffort.failure();
+        };
+
+        reader.readAsDataURL(originalImage);
+
+        return insertionEffort;
+    },
+
+    _dataUriToBlob: function(dataUri) {
+        "use strict";
+
+        var byteString, mimeString, arrayBuffer, intArray;
+
+        // convert base64 to raw binary data held in a string
+        if (dataUri.split(",")[0].indexOf("base64") >= 0) {
+            byteString = atob(dataUri.split(",")[1]);
+        }
+        else {
+            byteString = decodeURI(dataUri.split(",")[1]);
+        }
+
+        // extract the MIME
+        mimeString = dataUri.split(",")[0]
+            .split(":")[1]
+            .split(";")[0];
+
+        // write the bytes of the binary string to an ArrayBuffer
+        arrayBuffer = new ArrayBuffer(byteString.length);
+        intArray = new Uint8Array(arrayBuffer);
+        qq.each(byteString, function(idx, character) {
+            intArray[idx] = character.charCodeAt(0);
+        });
+
+        return this._createBlob(arrayBuffer, mimeString);
+    },
+
+    _createBlob: function(data, mime) {
+        "use strict";
+
+        var BlobBuilder = window.BlobBuilder ||
+                window.WebKitBlobBuilder ||
+                window.MozBlobBuilder ||
+                window.MSBlobBuilder,
+            blobBuilder = BlobBuilder && new BlobBuilder();
+
+        if (blobBuilder) {
+            blobBuilder.append(data);
+            return blobBuilder.getBlob(mime);
+        }
+        else {
+            return new Blob([data], {type: mime});
+        }
+    }
+});
+
+//Based on MinifyJpeg
+//http://elicon.blog57.fc2.com/blog-entry-206.html
+
+var ExifRestorer = (function()
+{
+   
+	var ExifRestorer = {};
+	 
+    ExifRestorer.KEY_STR = "ABCDEFGHIJKLMNOP" +
+                         "QRSTUVWXYZabcdef" +
+                         "ghijklmnopqrstuv" +
+                         "wxyz0123456789+/" +
+                         "=";
+
+    ExifRestorer.encode64 = function(input)
+    {
+        var output = "",
+            chr1, chr2, chr3 = "",
+            enc1, enc2, enc3, enc4 = "",
+            i = 0;
+
+        do {
+            chr1 = input[i++];
+            chr2 = input[i++];
+            chr3 = input[i++];
+
+            enc1 = chr1 >> 2;
+            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+            enc4 = chr3 & 63;
+
+            if (isNaN(chr2)) {
+               enc3 = enc4 = 64;
+            } else if (isNaN(chr3)) {
+               enc4 = 64;
+            }
+
+            output = output +
+               this.KEY_STR.charAt(enc1) +
+               this.KEY_STR.charAt(enc2) +
+               this.KEY_STR.charAt(enc3) +
+               this.KEY_STR.charAt(enc4);
+            chr1 = chr2 = chr3 = "";
+            enc1 = enc2 = enc3 = enc4 = "";
+        } while (i < input.length);
+
+        return output;
+    };
+    
+    ExifRestorer.restore = function(origFileBase64, resizedFileBase64)
+    {
+        var expectedBase64Header = "data:image/jpeg;base64,";
+
+        if (!origFileBase64.match(expectedBase64Header))
+        {
+        	return resizedFileBase64;
+        }       
+        
+        var rawImage = this.decode64(origFileBase64.replace(expectedBase64Header, ""));
+        var segments = this.slice2Segments(rawImage);
+                
+        var image = this.exifManipulation(resizedFileBase64, segments);
+        
+        return expectedBase64Header + this.encode64(image);
+        
+    };
+
+
+    ExifRestorer.exifManipulation = function(resizedFileBase64, segments)
+    {
+            var exifArray = this.getExifArray(segments),
+                newImageArray = this.insertExif(resizedFileBase64, exifArray),
+                aBuffer = new Uint8Array(newImageArray);
+
+            return aBuffer;
+    };
+
+
+    ExifRestorer.getExifArray = function(segments)
+    {
+            var seg;
+            for (var x = 0; x < segments.length; x++)
+            {
+                seg = segments[x];
+                if (seg[0] == 255 & seg[1] == 225) //(ff e1)
+                {
+                    return seg;
+                }
+            }
+            return [];
+    };
+
+
+    ExifRestorer.insertExif = function(resizedFileBase64, exifArray)
+    {
+            var imageData = resizedFileBase64.replace("data:image/jpeg;base64,", ""),
+                buf = this.decode64(imageData),
+                separatePoint = buf.indexOf(255,3),
+                mae = buf.slice(0, separatePoint),
+                ato = buf.slice(separatePoint),
+                array = mae;
+
+            array = array.concat(exifArray);
+            array = array.concat(ato);
+           return array;
+    };
+
+
+    
+    ExifRestorer.slice2Segments = function(rawImageArray)
+    {
+        var head = 0,
+            segments = [];
+
+        while (1)
+        {
+            if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 218){break;}
+            if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 216)
+            {
+                head += 2;
+            }
+            else
+            {
+                var length = rawImageArray[head + 2] * 256 + rawImageArray[head + 3],
+                    endPoint = head + length + 2,
+                    seg = rawImageArray.slice(head, endPoint);
+                segments.push(seg);
+                head = endPoint;
+            }
+            if (head > rawImageArray.length){break;}
+        }
+
+        return segments;
+    };
+
+
+    
+    ExifRestorer.decode64 = function(input) 
+    {
+        var output = "",
+            chr1, chr2, chr3 = "",
+            enc1, enc2, enc3, enc4 = "",
+            i = 0,
+            buf = [];
+
+        // remove all characters that are not A-Z, a-z, 0-9, +, /, or =
+        var base64test = /[^A-Za-z0-9\+\/\=]/g;
+        if (base64test.exec(input)) {
+            throw new Error("There were invalid base64 characters in the input text.  " +
+                "Valid base64 characters are A-Z, a-z, 0-9, '+', '/',and '='");
+        }
+        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+
+        do {
+            enc1 = this.KEY_STR.indexOf(input.charAt(i++));
+            enc2 = this.KEY_STR.indexOf(input.charAt(i++));
+            enc3 = this.KEY_STR.indexOf(input.charAt(i++));
+            enc4 = this.KEY_STR.indexOf(input.charAt(i++));
+
+            chr1 = (enc1 << 2) | (enc2 >> 4);
+            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+            chr3 = ((enc3 & 3) << 6) | enc4;
+
+            buf.push(chr1);
+
+            if (enc3 != 64) {
+               buf.push(chr2);
+            }
+            if (enc4 != 64) {
+               buf.push(chr3);
+            }
+
+            chr1 = chr2 = chr3 = "";
+            enc1 = enc2 = enc3 = enc4 = "";
+
+        } while (i < input.length);
+
+        return buf;
+    };
+
+    
+    return ExifRestorer;
+})();
+
+/* globals qq */
+/**
+ * Keeps a running tally of total upload progress for a batch of files.
+ *
+ * @param callback Invoked when total progress changes, passing calculated total loaded & total size values.
+ * @param getSize Function that returns the size of a file given its ID
+ * @constructor
+ */
+qq.TotalProgress = function(callback, getSize) {
+    "use strict";
+
+    var perFileProgress = {},
+        totalLoaded = 0,
+        totalSize = 0,
+
+        lastLoadedSent = -1,
+        lastTotalSent = -1,
+        callbackProxy = function(loaded, total) {
+            if (loaded !== lastLoadedSent || total !== lastTotalSent) {
+                callback(loaded, total);
+            }
+
+            lastLoadedSent = loaded;
+            lastTotalSent = total;
+        },
+
+        /**
+         * @param failed Array of file IDs that have failed
+         * @param retryable Array of file IDs that are retryable
+         * @returns true if none of the failed files are eligible for retry
+         */
+        noRetryableFiles = function(failed, retryable) {
+            var none = true;
+
+            qq.each(failed, function(idx, failedId) {
+                if (qq.indexOf(retryable, failedId) >= 0) {
+                    none = false;
+                    return false;
+                }
+            });
+
+            return none;
+        },
+
+        onCancel = function(id) {
+            updateTotalProgress(id, -1, -1);
+            delete perFileProgress[id];
+        },
+
+        onAllComplete = function(successful, failed, retryable) {
+            if (failed.length === 0 || noRetryableFiles(failed, retryable)) {
+                callbackProxy(totalSize, totalSize);
+                this.reset();
+            }
+        },
+
+        onNew = function(id) {
+            var size = getSize(id);
+
+            // We might not know the size yet, such as for blob proxies
+            if (size > 0) {
+                updateTotalProgress(id, 0, size);
+                perFileProgress[id] = {loaded: 0, total: size};
+            }
+        },
+
+        /**
+         * Invokes the callback with the current total progress of all files in the batch.  Called whenever it may
+         * be appropriate to re-calculate and dissemenate this data.
+         *
+         * @param id ID of a file that has changed in some important way
+         * @param newLoaded New loaded value for this file.  -1 if this value should no longer be part of calculations
+         * @param newTotal New total size of the file.  -1 if this value should no longer be part of calculations
+         */
+        updateTotalProgress = function(id, newLoaded, newTotal) {
+            var oldLoaded = perFileProgress[id] ? perFileProgress[id].loaded : 0,
+                oldTotal = perFileProgress[id] ? perFileProgress[id].total : 0;
+
+            if (newLoaded === -1 && newTotal === -1) {
+                totalLoaded -= oldLoaded;
+                totalSize -= oldTotal;
+            }
+            else {
+                if (newLoaded) {
+                    totalLoaded += newLoaded - oldLoaded;
+                }
+                if (newTotal) {
+                    totalSize += newTotal - oldTotal;
+                }
+            }
+
+            callbackProxy(totalLoaded, totalSize);
+        };
+
+    qq.extend(this, {
+        // Called when a batch of files has completed uploading.
+        onAllComplete: onAllComplete,
+
+        // Called when the status of a file has changed.
+        onStatusChange: function(id, oldStatus, newStatus) {
+            if (newStatus === qq.status.CANCELED || newStatus === qq.status.REJECTED) {
+                onCancel(id);
+            }
+            else if (newStatus === qq.status.SUBMITTING) {
+                onNew(id);
+            }
+        },
+
+        // Called whenever the upload progress of an individual file has changed.
+        onIndividualProgress: function(id, loaded, total) {
+            updateTotalProgress(id, loaded, total);
+            perFileProgress[id] = {loaded: loaded, total: total};
+        },
+
+        // Called whenever the total size of a file has changed, such as when the size of a generated blob is known.
+        onNewSize: function(id) {
+            onNew(id);
+        },
+
+        reset: function() {
+            perFileProgress = {};
+            totalLoaded = 0;
+            totalSize = 0;
+        }
+    });
+};
+
+/*globals qq */
+// Base handler for UI (FineUploader mode) events.
+// Some more specific handlers inherit from this one.
+qq.UiEventHandler = function(s, protectedApi) {
+    "use strict";
+
+    var disposer = new qq.DisposeSupport(),
+        spec = {
+            eventType: "click",
+            attachTo: null,
+            onHandled: function(target, event) {}
+        };
+
+    // This makes up the "public" API methods that will be accessible
+    // to instances constructing a base or child handler
+    qq.extend(this, {
+        addHandler: function(element) {
+            addHandler(element);
+        },
+
+        dispose: function() {
+            disposer.dispose();
+        }
+    });
+
+    function addHandler(element) {
+        disposer.attach(element, spec.eventType, function(event) {
+            // Only in IE: the `event` is a property of the `window`.
+            event = event || window.event;
+
+            // On older browsers, we must check the `srcElement` instead of the `target`.
+            var target = event.target || event.srcElement;
+
+            spec.onHandled(target, event);
+        });
+    }
+
+    // These make up the "protected" API methods that children of this base handler will utilize.
+    qq.extend(protectedApi, {
+        getFileIdFromItem: function(item) {
+            return item.qqFileId;
+        },
+
+        getDisposeSupport: function() {
+            return disposer;
+        }
+    });
+
+    qq.extend(spec, s);
+
+    if (spec.attachTo) {
+        addHandler(spec.attachTo);
+    }
+};
+
+/* global qq */
+qq.FileButtonsClickHandler = function(s) {
+    "use strict";
+
+    var inheritedInternalApi = {},
+        spec = {
+            templating: null,
+            log: function(message, lvl) {},
+            onDeleteFile: function(fileId) {},
+            onCancel: function(fileId) {},
+            onRetry: function(fileId) {},
+            onPause: function(fileId) {},
+            onContinue: function(fileId) {},
+            onGetName: function(fileId) {}
+        },
+        buttonHandlers = {
+            cancel: function(id) { spec.onCancel(id); },
+            retry:  function(id) { spec.onRetry(id); },
+            deleteButton: function(id) { spec.onDeleteFile(id); },
+            pause: function(id) { spec.onPause(id); },
+            continueButton: function(id) { spec.onContinue(id); }
+        };
+
+    function examineEvent(target, event) {
+        qq.each(buttonHandlers, function(buttonType, handler) {
+            var firstLetterCapButtonType = buttonType.charAt(0).toUpperCase() + buttonType.slice(1),
+                fileId;
+
+            if (spec.templating["is" + firstLetterCapButtonType](target)) {
+                fileId = spec.templating.getFileId(target);
+                qq.preventDefault(event);
+                spec.log(qq.format("Detected valid file button click event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
+                handler(fileId);
+                return false;
+            }
+        });
+    }
+
+    qq.extend(spec, s);
+
+    spec.eventType = "click";
+    spec.onHandled = examineEvent;
+    spec.attachTo = spec.templating.getFileList();
+
+    qq.extend(this, new qq.UiEventHandler(spec, inheritedInternalApi));
+};
+
+/*globals qq */
+// Child of FilenameEditHandler.  Used to detect click events on filename display elements.
+qq.FilenameClickHandler = function(s) {
+    "use strict";
+
+    var inheritedInternalApi = {},
+        spec = {
+            templating: null,
+            log: function(message, lvl) {},
+            classes: {
+                file: "qq-upload-file",
+                editNameIcon: "qq-edit-filename-icon"
+            },
+            onGetUploadStatus: function(fileId) {},
+            onGetName: function(fileId) {}
+        };
+
+    qq.extend(spec, s);
+
+    // This will be called by the parent handler when a `click` event is received on the list element.
+    function examineEvent(target, event) {
+        if (spec.templating.isFileName(target) || spec.templating.isEditIcon(target)) {
+            var fileId = spec.templating.getFileId(target),
+                status = spec.onGetUploadStatus(fileId);
+
+            // We only allow users to change filenames of files that have been submitted but not yet uploaded.
+            if (status === qq.status.SUBMITTED) {
+                spec.log(qq.format("Detected valid filename click event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
+                qq.preventDefault(event);
+
+                inheritedInternalApi.handleFilenameEdit(fileId, target, true);
+            }
+        }
+    }
+
+    spec.eventType = "click";
+    spec.onHandled = examineEvent;
+
+    qq.extend(this, new qq.FilenameEditHandler(spec, inheritedInternalApi));
+};
+
+/*globals qq */
+// Child of FilenameEditHandler.  Used to detect focusin events on file edit input elements.
+qq.FilenameInputFocusInHandler = function(s, inheritedInternalApi) {
+    "use strict";
+
+    var spec = {
+            templating: null,
+            onGetUploadStatus: function(fileId) {},
+            log: function(message, lvl) {}
+        };
+
+    if (!inheritedInternalApi) {
+        inheritedInternalApi = {};
+    }
+
+    // This will be called by the parent handler when a `focusin` event is received on the list element.
+    function handleInputFocus(target, event) {
+        if (spec.templating.isEditInput(target)) {
+            var fileId = spec.templating.getFileId(target),
+                status = spec.onGetUploadStatus(fileId);
+
+            if (status === qq.status.SUBMITTED) {
+                spec.log(qq.format("Detected valid filename input focus event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
+                inheritedInternalApi.handleFilenameEdit(fileId, target);
+            }
+        }
+    }
+
+    spec.eventType = "focusin";
+    spec.onHandled = handleInputFocus;
+
+    qq.extend(spec, s);
+    qq.extend(this, new qq.FilenameEditHandler(spec, inheritedInternalApi));
+};
+
+/*globals qq */
+/**
+ * Child of FilenameInputFocusInHandler.  Used to detect focus events on file edit input elements.  This child module is only
+ * needed for UAs that do not support the focusin event.  Currently, only Firefox lacks this event.
+ *
+ * @param spec Overrides for default specifications
+ */
+qq.FilenameInputFocusHandler = function(spec) {
+    "use strict";
+
+    spec.eventType = "focus";
+    spec.attachTo = null;
+
+    qq.extend(this, new qq.FilenameInputFocusInHandler(spec, {}));
+};
+
+/*globals qq */
+// Handles edit-related events on a file item (FineUploader mode).  This is meant to be a parent handler.
+// Children will delegate to this handler when specific edit-related actions are detected.
+qq.FilenameEditHandler = function(s, inheritedInternalApi) {
+    "use strict";
+
+    var spec = {
+            templating: null,
+            log: function(message, lvl) {},
+            onGetUploadStatus: function(fileId) {},
+            onGetName: function(fileId) {},
+            onSetName: function(fileId, newName) {},
+            onEditingStatusChange: function(fileId, isEditing) {}
+        };
+
+    function getFilenameSansExtension(fileId) {
+        var filenameSansExt = spec.onGetName(fileId),
+            extIdx = filenameSansExt.lastIndexOf(".");
+
+        if (extIdx > 0) {
+            filenameSansExt = filenameSansExt.substr(0, extIdx);
+        }
+
+        return filenameSansExt;
+    }
+
+    function getOriginalExtension(fileId) {
+        var origName = spec.onGetName(fileId);
+        return qq.getExtension(origName);
+    }
+
+    // Callback iff the name has been changed
+    function handleNameUpdate(newFilenameInputEl, fileId) {
+        var newName = newFilenameInputEl.value,
+            origExtension;
+
+        if (newName !== undefined && qq.trimStr(newName).length > 0) {
+            origExtension = getOriginalExtension(fileId);
+
+            if (origExtension !== undefined) {
+                newName = newName + "." + origExtension;
+            }
+
+            spec.onSetName(fileId, newName);
+        }
+
+        spec.onEditingStatusChange(fileId, false);
+    }
+
+    // The name has been updated if the filename edit input loses focus.
+    function registerInputBlurHandler(inputEl, fileId) {
+        inheritedInternalApi.getDisposeSupport().attach(inputEl, "blur", function() {
+            handleNameUpdate(inputEl, fileId);
+        });
+    }
+
+    // The name has been updated if the user presses enter.
+    function registerInputEnterKeyHandler(inputEl, fileId) {
+        inheritedInternalApi.getDisposeSupport().attach(inputEl, "keyup", function(event) {
+
+            var code = event.keyCode || event.which;
+
+            if (code === 13) {
+                handleNameUpdate(inputEl, fileId);
+            }
+        });
+    }
+
+    qq.extend(spec, s);
+
+    spec.attachTo = spec.templating.getFileList();
+
+    qq.extend(this, new qq.UiEventHandler(spec, inheritedInternalApi));
+
+    qq.extend(inheritedInternalApi, {
+        handleFilenameEdit: function(id, target, focusInput) {
+            var newFilenameInputEl = spec.templating.getEditInput(id);
+
+            spec.onEditingStatusChange(id, true);
+
+            newFilenameInputEl.value = getFilenameSansExtension(id);
+
+            if (focusInput) {
+                newFilenameInputEl.focus();
+            }
+
+            registerInputBlurHandler(newFilenameInputEl, id);
+            registerInputEnterKeyHandler(newFilenameInputEl, id);
+        }
+    });
+};
+
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * CryptoJS core components.
+ */
+var CryptoJS = CryptoJS || (function (Math, undefined) {
+    /**
+     * CryptoJS namespace.
+     */
+    var C = {};
+
+    /**
+     * Library namespace.
+     */
+    var C_lib = C.lib = {};
+
+    /**
+     * Base object for prototypal inheritance.
+     */
+    var Base = C_lib.Base = (function () {
+        function F() {}
+
+        return {
+            /**
+             * Creates a new object that inherits from this object.
+             *
+             * @param {Object} overrides Properties to copy into the new object.
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         field: 'value',
+             *
+             *         method: function () {
+             *         }
+             *     });
+             */
+            extend: function (overrides) {
+                // Spawn
+                F.prototype = this;
+                var subtype = new F();
+
+                // Augment
+                if (overrides) {
+                    subtype.mixIn(overrides);
+                }
+
+                // Create default initializer
+                if (!subtype.hasOwnProperty('init')) {
+                    subtype.init = function () {
+                        subtype.$super.init.apply(this, arguments);
+                    };
+                }
+
+                // Initializer's prototype is the subtype object
+                subtype.init.prototype = subtype;
+
+                // Reference supertype
+                subtype.$super = this;
+
+                return subtype;
+            },
+
+            /**
+             * Extends this object and runs the init method.
+             * Arguments to create() will be passed to init().
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var instance = MyType.create();
+             */
+            create: function () {
+                var instance = this.extend();
+                instance.init.apply(instance, arguments);
+
+                return instance;
+            },
+
+            /**
+             * Initializes a newly created object.
+             * Override this method to add some logic when your objects are created.
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         init: function () {
+             *             // ...
+             *         }
+             *     });
+             */
+            init: function () {
+            },
+
+            /**
+             * Copies properties into this object.
+             *
+             * @param {Object} properties The properties to mix in.
+             *
+             * @example
+             *
+             *     MyType.mixIn({
+             *         field: 'value'
+             *     });
+             */
+            mixIn: function (properties) {
+                for (var propertyName in properties) {
+                    if (properties.hasOwnProperty(propertyName)) {
+                        this[propertyName] = properties[propertyName];
+                    }
+                }
+
+                // IE won't copy toString using the loop above
+                if (properties.hasOwnProperty('toString')) {
+                    this.toString = properties.toString;
+                }
+            },
+
+            /**
+             * Creates a copy of this object.
+             *
+             * @return {Object} The clone.
+             *
+             * @example
+             *
+             *     var clone = instance.clone();
+             */
+            clone: function () {
+                return this.init.prototype.extend(this);
+            }
+        };
+    }());
+
+    /**
+     * An array of 32-bit words.
+     *
+     * @property {Array} words The array of 32-bit words.
+     * @property {number} sigBytes The number of significant bytes in this word array.
+     */
+    var WordArray = C_lib.WordArray = Base.extend({
+        /**
+         * Initializes a newly created word array.
+         *
+         * @param {Array} words (Optional) An array of 32-bit words.
+         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.lib.WordArray.create();
+         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
+         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
+         */
+        init: function (words, sigBytes) {
+            words = this.words = words || [];
+
+            if (sigBytes != undefined) {
+                this.sigBytes = sigBytes;
+            } else {
+                this.sigBytes = words.length * 4;
+            }
+        },
+
+        /**
+         * Converts this word array to a string.
+         *
+         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+         *
+         * @return {string} The stringified word array.
+         *
+         * @example
+         *
+         *     var string = wordArray + '';
+         *     var string = wordArray.toString();
+         *     var string = wordArray.toString(CryptoJS.enc.Utf8);
+         */
+        toString: function (encoder) {
+            return (encoder || Hex).stringify(this);
+        },
+
+        /**
+         * Concatenates a word array to this word array.
+         *
+         * @param {WordArray} wordArray The word array to append.
+         *
+         * @return {WordArray} This word array.
+         *
+         * @example
+         *
+         *     wordArray1.concat(wordArray2);
+         */
+        concat: function (wordArray) {
+            // Shortcuts
+            var thisWords = this.words;
+            var thatWords = wordArray.words;
+            var thisSigBytes = this.sigBytes;
+            var thatSigBytes = wordArray.sigBytes;
+
+            // Clamp excess bits
+            this.clamp();
+
+            // Concat
+            if (thisSigBytes % 4) {
+                // Copy one byte at a time
+                for (var i = 0; i < thatSigBytes; i++) {
+                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
+                }
+            } else if (thatWords.length > 0xffff) {
+                // Copy one word at a time
+                for (var i = 0; i < thatSigBytes; i += 4) {
+                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
+                }
+            } else {
+                // Copy all words at once
+                thisWords.push.apply(thisWords, thatWords);
+            }
+            this.sigBytes += thatSigBytes;
+
+            // Chainable
+            return this;
+        },
+
+        /**
+         * Removes insignificant bits.
+         *
+         * @example
+         *
+         *     wordArray.clamp();
+         */
+        clamp: function () {
+            // Shortcuts
+            var words = this.words;
+            var sigBytes = this.sigBytes;
+
+            // Clamp
+            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
+            words.length = Math.ceil(sigBytes / 4);
+        },
+
+        /**
+         * Creates a copy of this word array.
+         *
+         * @return {WordArray} The clone.
+         *
+         * @example
+         *
+         *     var clone = wordArray.clone();
+         */
+        clone: function () {
+            var clone = Base.clone.call(this);
+            clone.words = this.words.slice(0);
+
+            return clone;
+        },
+
+        /**
+         * Creates a word array filled with random bytes.
+         *
+         * @param {number} nBytes The number of random bytes to generate.
+         *
+         * @return {WordArray} The random word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.lib.WordArray.random(16);
+         */
+        random: function (nBytes) {
+            var words = [];
+            for (var i = 0; i < nBytes; i += 4) {
+                words.push((Math.random() * 0x100000000) | 0);
+            }
+
+            return new WordArray.init(words, nBytes);
+        }
+    });
+
+    /**
+     * Encoder namespace.
+     */
+    var C_enc = C.enc = {};
+
+    /**
+     * Hex encoding strategy.
+     */
+    var Hex = C_enc.Hex = {
+        /**
+         * Converts a word array to a hex string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The hex string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            // Shortcuts
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+
+            // Convert
+            var hexChars = [];
+            for (var i = 0; i < sigBytes; i++) {
+                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+                hexChars.push((bite >>> 4).toString(16));
+                hexChars.push((bite & 0x0f).toString(16));
+            }
+
+            return hexChars.join('');
+        },
+
+        /**
+         * Converts a hex string to a word array.
+         *
+         * @param {string} hexStr The hex string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
+         */
+        parse: function (hexStr) {
+            // Shortcut
+            var hexStrLength = hexStr.length;
+
+            // Convert
+            var words = [];
+            for (var i = 0; i < hexStrLength; i += 2) {
+                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
+            }
+
+            return new WordArray.init(words, hexStrLength / 2);
+        }
+    };
+
+    /**
+     * Latin1 encoding strategy.
+     */
+    var Latin1 = C_enc.Latin1 = {
+        /**
+         * Converts a word array to a Latin1 string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The Latin1 string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            // Shortcuts
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+
+            // Convert
+            var latin1Chars = [];
+            for (var i = 0; i < sigBytes; i++) {
+                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+                latin1Chars.push(String.fromCharCode(bite));
+            }
+
+            return latin1Chars.join('');
+        },
+
+        /**
+         * Converts a Latin1 string to a word array.
+         *
+         * @param {string} latin1Str The Latin1 string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
+         */
+        parse: function (latin1Str) {
+            // Shortcut
+            var latin1StrLength = latin1Str.length;
+
+            // Convert
+            var words = [];
+            for (var i = 0; i < latin1StrLength; i++) {
+                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
+            }
+
+            return new WordArray.init(words, latin1StrLength);
+        }
+    };
+
+    /**
+     * UTF-8 encoding strategy.
+     */
+    var Utf8 = C_enc.Utf8 = {
+        /**
+         * Converts a word array to a UTF-8 string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The UTF-8 string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            try {
+                return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+            } catch (e) {
+                throw new Error('Malformed UTF-8 data');
+            }
+        },
+
+        /**
+         * Converts a UTF-8 string to a word array.
+         *
+         * @param {string} utf8Str The UTF-8 string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
+         */
+        parse: function (utf8Str) {
+            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+        }
+    };
+
+    /**
+     * Abstract buffered block algorithm template.
+     *
+     * The property blockSize must be implemented in a concrete subtype.
+     *
+     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
+     */
+    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+        /**
+         * Resets this block algorithm's data buffer to its initial state.
+         *
+         * @example
+         *
+         *     bufferedBlockAlgorithm.reset();
+         */
+        reset: function () {
+            // Initial values
+            this._data = new WordArray.init();
+            this._nDataBytes = 0;
+        },
+
+        /**
+         * Adds new data to this block algorithm's buffer.
+         *
+         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
+         *
+         * @example
+         *
+         *     bufferedBlockAlgorithm._append('data');
+         *     bufferedBlockAlgorithm._append(wordArray);
+         */
+        _append: function (data) {
+            // Convert string to WordArray, else assume WordArray already
+            if (typeof data == 'string') {
+                data = Utf8.parse(data);
+            }
+
+            // Append
+            this._data.concat(data);
+            this._nDataBytes += data.sigBytes;
+        },
+
+        /**
+         * Processes available data blocks.
+         *
+         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+         *
+         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
+         *
+         * @return {WordArray} The processed data.
+         *
+         * @example
+         *
+         *     var processedData = bufferedBlockAlgorithm._process();
+         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
+         */
+        _process: function (doFlush) {
+            // Shortcuts
+            var data = this._data;
+            var dataWords = data.words;
+            var dataSigBytes = data.sigBytes;
+            var blockSize = this.blockSize;
+            var blockSizeBytes = blockSize * 4;
+
+            // Count blocks ready
+            var nBlocksReady = dataSigBytes / blockSizeBytes;
+            if (doFlush) {
+                // Round up to include partial blocks
+                nBlocksReady = Math.ceil(nBlocksReady);
+            } else {
+                // Round down to include only full blocks,
+                // less the number of blocks that must remain in the buffer
+                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+            }
+
+            // Count words ready
+            var nWordsReady = nBlocksReady * blockSize;
+
+            // Count bytes ready
+            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
+
+            // Process blocks
+            if (nWordsReady) {
+                for (var offset = 0; offset < nWordsReady; offset += blockSize) {
+                    // Perform concrete-algorithm logic
+                    this._doProcessBlock(dataWords, offset);
+                }
+
+                // Remove processed words
+                var processedWords = dataWords.splice(0, nWordsReady);
+                data.sigBytes -= nBytesReady;
+            }
+
+            // Return processed words
+            return new WordArray.init(processedWords, nBytesReady);
+        },
+
+        /**
+         * Creates a copy of this object.
+         *
+         * @return {Object} The clone.
+         *
+         * @example
+         *
+         *     var clone = bufferedBlockAlgorithm.clone();
+         */
+        clone: function () {
+            var clone = Base.clone.call(this);
+            clone._data = this._data.clone();
+
+            return clone;
+        },
+
+        _minBufferSize: 0
+    });
+
+    /**
+     * Abstract hasher template.
+     *
+     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
+     */
+    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+        /**
+         * Configuration options.
+         */
+        cfg: Base.extend(),
+
+        /**
+         * Initializes a newly created hasher.
+         *
+         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
+         *
+         * @example
+         *
+         *     var hasher = CryptoJS.algo.SHA256.create();
+         */
+        init: function (cfg) {
+            // Apply config defaults
+            this.cfg = this.cfg.extend(cfg);
+
+            // Set initial values
+            this.reset();
+        },
+
+        /**
+         * Resets this hasher to its initial state.
+         *
+         * @example
+         *
+         *     hasher.reset();
+         */
+        reset: function () {
+            // Reset data buffer
+            BufferedBlockAlgorithm.reset.call(this);
+
+            // Perform concrete-hasher logic
+            this._doReset();
+        },
+
+        /**
+         * Updates this hasher with a message.
+         *
+         * @param {WordArray|string} messageUpdate The message to append.
+         *
+         * @return {Hasher} This hasher.
+         *
+         * @example
+         *
+         *     hasher.update('message');
+         *     hasher.update(wordArray);
+         */
+        update: function (messageUpdate) {
+            // Append
+            this._append(messageUpdate);
+
+            // Update the hash
+            this._process();
+
+            // Chainable
+            return this;
+        },
+
+        /**
+         * Finalizes the hash computation.
+         * Note that the finalize operation is effectively a destructive, read-once operation.
+         *
+         * @param {WordArray|string} messageUpdate (Optional) A final message update.
+         *
+         * @return {WordArray} The hash.
+         *
+         * @example
+         *
+         *     var hash = hasher.finalize();
+         *     var hash = hasher.finalize('message');
+         *     var hash = hasher.finalize(wordArray);
+         */
+        finalize: function (messageUpdate) {
+            // Final message update
+            if (messageUpdate) {
+                this._append(messageUpdate);
+            }
+
+            // Perform concrete-hasher logic
+            var hash = this._doFinalize();
+
+            return hash;
+        },
+
+        blockSize: 512/32,
+
+        /**
+         * Creates a shortcut function to a hasher's object interface.
+         *
+         * @param {Hasher} hasher The hasher to create a helper for.
+         *
+         * @return {Function} The shortcut function.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
+         */
+        _createHelper: function (hasher) {
+            return function (message, cfg) {
+                return new hasher.init(cfg).finalize(message);
+            };
+        },
+
+        /**
+         * Creates a shortcut function to the HMAC's object interface.
+         *
+         * @param {Hasher} hasher The hasher to use in this HMAC helper.
+         *
+         * @return {Function} The shortcut function.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
+         */
+        _createHmacHelper: function (hasher) {
+            return function (message, key) {
+                return new C_algo.HMAC.init(hasher, key).finalize(message);
+            };
+        }
+    });
+
+    /**
+     * Algorithm namespace.
+     */
+    var C_algo = C.algo = {};
+
+    return C;
+}(Math));
+
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var WordArray = C_lib.WordArray;
+    var C_enc = C.enc;
+
+    /**
+     * Base64 encoding strategy.
+     */
+    var Base64 = C_enc.Base64 = {
+        /**
+         * Converts a word array to a Base64 string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The Base64 string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            // Shortcuts
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+            var map = this._map;
+
+            // Clamp excess bits
+            wordArray.clamp();
+
+            // Convert
+            var base64Chars = [];
+            for (var i = 0; i < sigBytes; i += 3) {
+                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;
+                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
+                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
+
+                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
+
+                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
+                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
+                }
+            }
+
+            // Add padding
+            var paddingChar = map.charAt(64);
+            if (paddingChar) {
+                while (base64Chars.length % 4) {
+                    base64Chars.push(paddingChar);
+                }
+            }
+
+            return base64Chars.join('');
+        },
+
+        /**
+         * Converts a Base64 string to a word array.
+         *
+         * @param {string} base64Str The Base64 string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
+         */
+        parse: function (base64Str) {
+            // Shortcuts
+            var base64StrLength = base64Str.length;
+            var map = this._map;
+
+            // Ignore padding
+            var paddingChar = map.charAt(64);
+            if (paddingChar) {
+                var paddingIndex = base64Str.indexOf(paddingChar);
+                if (paddingIndex != -1) {
+                    base64StrLength = paddingIndex;
+                }
+            }
+
+            // Convert
+            var words = [];
+            var nBytes = 0;
+            for (var i = 0; i < base64StrLength; i++) {
+                if (i % 4) {
+                    var bits1 = map.indexOf(base64Str.charAt(i - 1)) << ((i % 4) * 2);
+                    var bits2 = map.indexOf(base64Str.charAt(i)) >>> (6 - (i % 4) * 2);
+                    words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
+                    nBytes++;
+                }
+            }
+
+            return WordArray.create(words, nBytes);
+        },
+
+        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
+    };
+}());
+
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var Base = C_lib.Base;
+    var C_enc = C.enc;
+    var Utf8 = C_enc.Utf8;
+    var C_algo = C.algo;
+
+    /**
+     * HMAC algorithm.
+     */
+    var HMAC = C_algo.HMAC = Base.extend({
+        /**
+         * Initializes a newly created HMAC.
+         *
+         * @param {Hasher} hasher The hash algorithm to use.
+         * @param {WordArray|string} key The secret key.
+         *
+         * @example
+         *
+         *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
+         */
+        init: function (hasher, key) {
+            // Init hasher
+            hasher = this._hasher = new hasher.init();
+
+            // Convert string to WordArray, else assume WordArray already
+            if (typeof key == 'string') {
+                key = Utf8.parse(key);
+            }
+
+            // Shortcuts
+            var hasherBlockSize = hasher.blockSize;
+            var hasherBlockSizeBytes = hasherBlockSize * 4;
+
+            // Allow arbitrary length keys
+            if (key.sigBytes > hasherBlockSizeBytes) {
+                key = hasher.finalize(key);
+            }
+
+            // Clamp excess bits
+            key.clamp();
+
+            // Clone key for inner and outer pads
+            var oKey = this._oKey = key.clone();
+            var iKey = this._iKey = key.clone();
+
+            // Shortcuts
+            var oKeyWords = oKey.words;
+            var iKeyWords = iKey.words;
+
+            // XOR keys with pad constants
+            for (var i = 0; i < hasherBlockSize; i++) {
+                oKeyWords[i] ^= 0x5c5c5c5c;
+                iKeyWords[i] ^= 0x36363636;
+            }
+            oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
+
+            // Set initial values
+            this.reset();
+        },
+
+        /**
+         * Resets this HMAC to its initial state.
+         *
+         * @example
+         *
+         *     hmacHasher.reset();
+         */
+        reset: function () {
+            // Shortcut
+            var hasher = this._hasher;
+
+            // Reset
+            hasher.reset();
+            hasher.update(this._iKey);
+        },
+
+        /**
+         * Updates this HMAC with a message.
+         *
+         * @param {WordArray|string} messageUpdate The message to append.
+         *
+         * @return {HMAC} This HMAC instance.
+         *
+         * @example
+         *
+         *     hmacHasher.update('message');
+         *     hmacHasher.update(wordArray);
+         */
+        update: function (messageUpdate) {
+            this._hasher.update(messageUpdate);
+
+            // Chainable
+            return this;
+        },
+
+        /**
+         * Finalizes the HMAC computation.
+         * Note that the finalize operation is effectively a destructive, read-once operation.
+         *
+         * @param {WordArray|string} messageUpdate (Optional) A final message update.
+         *
+         * @return {WordArray} The HMAC.
+         *
+         * @example
+         *
+         *     var hmac = hmacHasher.finalize();
+         *     var hmac = hmacHasher.finalize('message');
+         *     var hmac = hmacHasher.finalize(wordArray);
+         */
+        finalize: function (messageUpdate) {
+            // Shortcut
+            var hasher = this._hasher;
+
+            // Compute HMAC
+            var innerHash = hasher.finalize(messageUpdate);
+            hasher.reset();
+            var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
+
+            return hmac;
+        }
+    });
+}());
+
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var WordArray = C_lib.WordArray;
+    var Hasher = C_lib.Hasher;
+    var C_algo = C.algo;
+
+    // Reusable object
+    var W = [];
+
+    /**
+     * SHA-1 hash algorithm.
+     */
+    var SHA1 = C_algo.SHA1 = Hasher.extend({
+        _doReset: function () {
+            this._hash = new WordArray.init([
+                0x67452301, 0xefcdab89,
+                0x98badcfe, 0x10325476,
+                0xc3d2e1f0
+            ]);
+        },
+
+        _doProcessBlock: function (M, offset) {
+            // Shortcut
+            var H = this._hash.words;
+
+            // Working variables
+            var a = H[0];
+            var b = H[1];
+            var c = H[2];
+            var d = H[3];
+            var e = H[4];
+
+            // Computation
+            for (var i = 0; i < 80; i++) {
+                if (i < 16) {
+                    W[i] = M[offset + i] | 0;
+                } else {
+                    var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+                    W[i] = (n << 1) | (n >>> 31);
+                }
+
+                var t = ((a << 5) | (a >>> 27)) + e + W[i];
+                if (i < 20) {
+                    t += ((b & c) | (~b & d)) + 0x5a827999;
+                } else if (i < 40) {
+                    t += (b ^ c ^ d) + 0x6ed9eba1;
+                } else if (i < 60) {
+                    t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;
+                } else /* if (i < 80) */ {
+                    t += (b ^ c ^ d) - 0x359d3e2a;
+                }
+
+                e = d;
+                d = c;
+                c = (b << 30) | (b >>> 2);
+                b = a;
+                a = t;
+            }
+
+            // Intermediate hash value
+            H[0] = (H[0] + a) | 0;
+            H[1] = (H[1] + b) | 0;
+            H[2] = (H[2] + c) | 0;
+            H[3] = (H[3] + d) | 0;
+            H[4] = (H[4] + e) | 0;
+        },
+
+        _doFinalize: function () {
+            // Shortcuts
+            var data = this._data;
+            var dataWords = data.words;
+
+            var nBitsTotal = this._nDataBytes * 8;
+            var nBitsLeft = data.sigBytes * 8;
+
+            // Add padding
+            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
+            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
+            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
+            data.sigBytes = dataWords.length * 4;
+
+            // Hash final blocks
+            this._process();
+
+            // Return final computed hash
+            return this._hash;
+        },
+
+        clone: function () {
+            var clone = Hasher.clone.call(this);
+            clone._hash = this._hash.clone();
+
+            return clone;
+        }
+    });
+
+    /**
+     * Shortcut function to the hasher's object interface.
+     *
+     * @param {WordArray|string} message The message to hash.
+     *
+     * @return {WordArray} The hash.
+     *
+     * @static
+     *
+     * @example
+     *
+     *     var hash = CryptoJS.SHA1('message');
+     *     var hash = CryptoJS.SHA1(wordArray);
+     */
+    C.SHA1 = Hasher._createHelper(SHA1);
+
+    /**
+     * Shortcut function to the HMAC's object interface.
+     *
+     * @param {WordArray|string} message The message to hash.
+     * @param {WordArray|string} key The secret key.
+     *
+     * @return {WordArray} The HMAC.
+     *
+     * @static
+     *
+     * @example
+     *
+     *     var hmac = CryptoJS.HmacSHA1(message, key);
+     */
+    C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
+}());
+
+/*! 2015-06-09 */
diff --git a/js/components/ascribe_uploader/vendor/s3.fine-uploader.min.js b/js/components/ascribe_uploader/vendor/s3.fine-uploader.min.js
new file mode 100644
index 00000000..ef244d9e
--- /dev/null
+++ b/js/components/ascribe_uploader/vendor/s3.fine-uploader.min.js
@@ -0,0 +1,22 @@
+/*!
+* Fine Uploader
+*
+* Copyright 2015, Widen Enterprises, Inc. info@fineuploader.com
+*
+* Version: 5.2.2
+*
+* Homepage: http://fineuploader.com
+*
+* Repository: git://github.com/FineUploader/fine-uploader.git
+*
+* Licensed only under the Widen Commercial License (http://fineuploader.com/licensing).
+*/ 
+
+
+var qq=function(a){"use strict";return{hide:function(){return a.style.display="none",this},attach:function(b,c){return a.addEventListener?a.addEventListener(b,c,!1):a.attachEvent&&a.attachEvent("on"+b,c),function(){qq(a).detach(b,c)}},detach:function(b,c){return a.removeEventListener?a.removeEventListener(b,c,!1):a.attachEvent&&a.detachEvent("on"+b,c),this},contains:function(b){return b?a===b?!0:a.contains?a.contains(b):!!(8&b.compareDocumentPosition(a)):!1},insertBefore:function(b){return b.parentNode.insertBefore(a,b),this},remove:function(){return a.parentNode.removeChild(a),this},css:function(b){if(null==a.style)throw new qq.Error("Can't apply style to node as it is not on the HTMLElement prototype chain!");return null!=b.opacity&&"string"!=typeof a.style.opacity&&"undefined"!=typeof a.filters&&(b.filter="alpha(opacity="+Math.round(100*b.opacity)+")"),qq.extend(a.style,b),this},hasClass:function(b,c){var d=new RegExp("(^| )"+b+"( |$)");return d.test(a.className)||!(!c||!d.test(a.parentNode.className))},addClass:function(b){return qq(a).hasClass(b)||(a.className+=" "+b),this},removeClass:function(b){var c=new RegExp("(^| )"+b+"( |$)");return a.className=a.className.replace(c," ").replace(/^\s+|\s+$/g,""),this},getByClass:function(b){var c,d=[];return a.querySelectorAll?a.querySelectorAll("."+b):(c=a.getElementsByTagName("*"),qq.each(c,function(a,c){qq(c).hasClass(b)&&d.push(c)}),d)},children:function(){for(var b=[],c=a.firstChild;c;)1===c.nodeType&&b.push(c),c=c.nextSibling;return b},setText:function(b){return a.innerText=b,a.textContent=b,this},clearText:function(){return qq(a).setText("")},hasAttribute:function(b){var c;return a.hasAttribute?a.hasAttribute(b)?null==/^false$/i.exec(a.getAttribute(b)):!1:(c=a[b],void 0===c?!1:null==/^false$/i.exec(c))}}};!function(){"use strict";qq.canvasToBlob=function(a,b,c){return qq.dataUriToBlob(a.toDataURL(b,c))},qq.dataUriToBlob=function(a){var b,c,d,e,f=function(a,b){var c=window.BlobBuilder||window.WebKitBlobBuilder||window.MozBlobBuilder||window.MSBlobBuilder,d=c&&new c;return d?(d.append(a),d.getBlob(b)):new Blob([a],{type:b})};return c=a.split(",")[0].indexOf("base64")>=0?atob(a.split(",")[1]):decodeURI(a.split(",")[1]),e=a.split(",")[0].split(":")[1].split(";")[0],b=new ArrayBuffer(c.length),d=new Uint8Array(b),qq.each(c,function(a,b){d[a]=b.charCodeAt(0)}),f(b,e)},qq.log=function(a,b){window.console&&(b&&"info"!==b?window.console[b]?window.console[b](a):window.console.log("<"+b+"> "+a):window.console.log(a))},qq.isObject=function(a){return a&&!a.nodeType&&"[object Object]"===Object.prototype.toString.call(a)},qq.isFunction=function(a){return"function"==typeof a},qq.isArray=function(a){return"[object Array]"===Object.prototype.toString.call(a)||a&&window.ArrayBuffer&&a.buffer&&a.buffer.constructor===ArrayBuffer},qq.isItemList=function(a){return"[object DataTransferItemList]"===Object.prototype.toString.call(a)},qq.isNodeList=function(a){return"[object NodeList]"===Object.prototype.toString.call(a)||a.item&&a.namedItem},qq.isString=function(a){return"[object String]"===Object.prototype.toString.call(a)},qq.trimStr=function(a){return String.prototype.trim?a.trim():a.replace(/^\s+|\s+$/g,"")},qq.format=function(a){var b=Array.prototype.slice.call(arguments,1),c=a,d=c.indexOf("{}");return qq.each(b,function(a,b){var e=c.substring(0,d),f=c.substring(d+2);return c=e+b+f,d=c.indexOf("{}",d+b.length),0>d?!1:void 0}),c},qq.isFile=function(a){return window.File&&"[object File]"===Object.prototype.toString.call(a)},qq.isFileList=function(a){return window.FileList&&"[object FileList]"===Object.prototype.toString.call(a)},qq.isFileOrInput=function(a){return qq.isFile(a)||qq.isInput(a)},qq.isInput=function(a,b){var c=function(a){var c=a.toLowerCase();return b?"file"!==c:"file"===c};return window.HTMLInputElement&&"[object HTMLInputElement]"===Object.prototype.toString.call(a)&&a.type&&c(a.type)?!0:a.tagName&&"input"===a.tagName.toLowerCase()&&a.type&&c(a.type)?!0:!1},qq.isBlob=function(a){return window.Blob&&"[object Blob]"===Object.prototype.toString.call(a)?!0:void 0},qq.isXhrUploadSupported=function(){var a=document.createElement("input");return a.type="file",void 0!==a.multiple&&"undefined"!=typeof File&&"undefined"!=typeof FormData&&"undefined"!=typeof qq.createXhrInstance().upload},qq.createXhrInstance=function(){if(window.XMLHttpRequest)return new XMLHttpRequest;try{return new ActiveXObject("MSXML2.XMLHTTP.3.0")}catch(a){return qq.log("Neither XHR or ActiveX are supported!","error"),null}},qq.isFolderDropSupported=function(a){return a.items&&a.items.length>0&&a.items[0].webkitGetAsEntry},qq.isFileChunkingSupported=function(){return!qq.androidStock()&&qq.isXhrUploadSupported()&&(void 0!==File.prototype.slice||void 0!==File.prototype.webkitSlice||void 0!==File.prototype.mozSlice)},qq.sliceBlob=function(a,b,c){var d=a.slice||a.mozSlice||a.webkitSlice;return d.call(a,b,c)},qq.arrayBufferToHex=function(a){var b="",c=new Uint8Array(a);return qq.each(c,function(a,c){var d=c.toString(16);d.length<2&&(d="0"+d),b+=d}),b},qq.readBlobToHex=function(a,b,c){var d=qq.sliceBlob(a,b,b+c),e=new FileReader,f=new qq.Promise;return e.onload=function(){f.success(qq.arrayBufferToHex(e.result))},e.onerror=f.failure,e.readAsArrayBuffer(d),f},qq.extend=function(a,b,c){return qq.each(b,function(b,d){c&&qq.isObject(d)?(void 0===a[b]&&(a[b]={}),qq.extend(a[b],d,!0)):a[b]=d}),a},qq.override=function(a,b){var c={},d=b(c);return qq.each(d,function(b,d){void 0!==a[b]&&(c[b]=a[b]),a[b]=d}),a},qq.indexOf=function(a,b,c){if(a.indexOf)return a.indexOf(b,c);c=c||0;var d=a.length;for(0>c&&(c+=d);d>c;c+=1)if(a.hasOwnProperty(c)&&a[c]===b)return c;return-1},qq.getUniqueId=function(){return"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,function(a){var b=0|16*Math.random(),c="x"==a?b:8|3&b;return c.toString(16)})},qq.ie=function(){return-1!==navigator.userAgent.indexOf("MSIE")||-1!==navigator.userAgent.indexOf("Trident")},qq.ie7=function(){return-1!==navigator.userAgent.indexOf("MSIE 7")},qq.ie8=function(){return-1!==navigator.userAgent.indexOf("MSIE 8")},qq.ie10=function(){return-1!==navigator.userAgent.indexOf("MSIE 10")},qq.ie11=function(){return qq.ie()&&-1!==navigator.userAgent.indexOf("rv:11")},qq.safari=function(){return void 0!==navigator.vendor&&-1!==navigator.vendor.indexOf("Apple")},qq.chrome=function(){return void 0!==navigator.vendor&&-1!==navigator.vendor.indexOf("Google")},qq.opera=function(){return void 0!==navigator.vendor&&-1!==navigator.vendor.indexOf("Opera")},qq.firefox=function(){return!qq.ie11()&&-1!==navigator.userAgent.indexOf("Mozilla")&&void 0!==navigator.vendor&&""===navigator.vendor},qq.windows=function(){return"Win32"===navigator.platform},qq.android=function(){return-1!==navigator.userAgent.toLowerCase().indexOf("android")},qq.androidStock=function(){return qq.android()&&navigator.userAgent.toLowerCase().indexOf("chrome")<0},qq.ios6=function(){return qq.ios()&&-1!==navigator.userAgent.indexOf(" OS 6_")},qq.ios7=function(){return qq.ios()&&-1!==navigator.userAgent.indexOf(" OS 7_")},qq.ios8=function(){return qq.ios()&&-1!==navigator.userAgent.indexOf(" OS 8_")},qq.ios800=function(){return qq.ios()&&-1!==navigator.userAgent.indexOf(" OS 8_0 ")},qq.ios=function(){return-1!==navigator.userAgent.indexOf("iPad")||-1!==navigator.userAgent.indexOf("iPod")||-1!==navigator.userAgent.indexOf("iPhone")},qq.iosChrome=function(){return qq.ios()&&-1!==navigator.userAgent.indexOf("CriOS")},qq.iosSafari=function(){return qq.ios()&&!qq.iosChrome()&&-1!==navigator.userAgent.indexOf("Safari")},qq.iosSafariWebView=function(){return qq.ios()&&!qq.iosChrome()&&!qq.iosSafari()},qq.preventDefault=function(a){a.preventDefault?a.preventDefault():a.returnValue=!1},qq.toElement=function(){var a=document.createElement("div");return function(b){a.innerHTML=b;var c=a.firstChild;return a.removeChild(c),c}}(),qq.each=function(a,b){var c,d;if(a)if(window.Storage&&a.constructor===window.Storage)for(c=0;c<a.length&&(d=b(a.key(c),a.getItem(a.key(c))),d!==!1);c++);else if(qq.isArray(a)||qq.isItemList(a)||qq.isNodeList(a))for(c=0;c<a.length&&(d=b(c,a[c]),d!==!1);c++);else if(qq.isString(a))for(c=0;c<a.length&&(d=b(c,a.charAt(c)),d!==!1);c++);else for(c in a)if(Object.prototype.hasOwnProperty.call(a,c)&&(d=b(c,a[c]),d===!1))break},qq.bind=function(a,b){if(qq.isFunction(a)){var c=Array.prototype.slice.call(arguments,2);return function(){var d=qq.extend([],c);return arguments.length&&(d=d.concat(Array.prototype.slice.call(arguments))),a.apply(b,d)}}throw new Error("first parameter must be a function!")},qq.obj2url=function(a,b,c){var d=[],e="&",f=function(a,c){var e=b?/\[\]$/.test(b)?b:b+"["+c+"]":c;"undefined"!==e&&"undefined"!==c&&d.push("object"==typeof a?qq.obj2url(a,e,!0):"[object Function]"===Object.prototype.toString.call(a)?encodeURIComponent(e)+"="+encodeURIComponent(a()):encodeURIComponent(e)+"="+encodeURIComponent(a))};return!c&&b?(e=/\?/.test(b)?/\?$/.test(b)?"":"&":"?",d.push(b),d.push(qq.obj2url(a))):"[object Array]"===Object.prototype.toString.call(a)&&"undefined"!=typeof a?qq.each(a,function(a,b){f(b,a)}):"undefined"!=typeof a&&null!==a&&"object"==typeof a?qq.each(a,function(a,b){f(b,a)}):d.push(encodeURIComponent(b)+"="+encodeURIComponent(a)),b?d.join(e):d.join(e).replace(/^&/,"").replace(/%20/g,"+")},qq.obj2FormData=function(a,b,c){return b||(b=new FormData),qq.each(a,function(a,d){a=c?c+"["+a+"]":a,qq.isObject(d)?qq.obj2FormData(d,b,a):qq.isFunction(d)?b.append(a,d()):b.append(a,d)}),b},qq.obj2Inputs=function(a,b){var c;return b||(b=document.createElement("form")),qq.obj2FormData(a,{append:function(a,d){c=document.createElement("input"),c.setAttribute("name",a),c.setAttribute("value",d),b.appendChild(c)}}),b},qq.parseJson=function(json){return window.JSON&&qq.isFunction(JSON.parse)?JSON.parse(json):eval("("+json+")")},qq.getExtension=function(a){var b=a.lastIndexOf(".")+1;return b>0?a.substr(b,a.length-b):void 0},qq.getFilename=function(a){return qq.isInput(a)?a.value.replace(/.*(\/|\\)/,""):qq.isFile(a)&&null!==a.fileName&&void 0!==a.fileName?a.fileName:a.name},qq.DisposeSupport=function(){var a=[];return{dispose:function(){var b;do b=a.shift(),b&&b();while(b)},attach:function(){var a=arguments;this.addDisposer(qq(a[0]).attach.apply(this,Array.prototype.slice.call(arguments,1)))},addDisposer:function(b){a.push(b)}}}}(),function(){"use strict";qq.Error=function(a){this.message="[Fine Uploader "+qq.version+"] "+a},qq.Error.prototype=new Error}(),qq.version="5.2.2",qq.supportedFeatures=function(){"use strict";function a(){var a,b=!0;try{a=document.createElement("input"),a.type="file",qq(a).hide(),a.disabled&&(b=!1)}catch(c){b=!1}return b}function b(){return(qq.chrome()||qq.opera())&&void 0!==navigator.userAgent.match(/Chrome\/[2][1-9]|Chrome\/[3-9][0-9]/)}function c(){return(qq.chrome()||qq.opera())&&void 0!==navigator.userAgent.match(/Chrome\/[1][4-9]|Chrome\/[2-9][0-9]/)}function d(){if(window.XMLHttpRequest){var a=qq.createXhrInstance();return void 0!==a.withCredentials}return!1}function e(){return void 0!==window.XDomainRequest}function f(){return d()?!0:e()}function g(){return void 0!==document.createElement("input").webkitdirectory}function h(){try{return!!window.localStorage}catch(a){return!1}}function i(){var a=document.createElement("span");return("draggable"in a||"ondragstart"in a&&"ondrop"in a)&&!qq.android()&&!qq.ios()}var j,k,l,m,n,o,p,q,r,s,t,u,v,w,x;return j=a(),m=j&&qq.isXhrUploadSupported(),k=m&&!qq.androidStock(),l=m&&i(),n=l&&b(),o=m&&qq.isFileChunkingSupported(),p=m&&o&&h(),q=m&&c(),r=j&&(void 0!==window.postMessage||m),t=d(),s=e(),u=f(),v=g(),w=m&&void 0!==window.FileReader,x=function(){return m?!qq.androidStock()&&!qq.iosChrome():!1}(),{ajaxUploading:m,blobUploading:k,canDetermineSize:m,chunking:o,deleteFileCors:u,deleteFileCorsXdr:s,deleteFileCorsXhr:t,dialogElement:!!window.HTMLDialogElement,fileDrop:l,folderDrop:n,folderSelection:v,imagePreviews:w,imageValidation:w,itemSizeValidation:m,pause:o,progressBar:x,resume:p,scaling:w&&k,tiffPreviews:qq.safari(),unlimitedScaledImageSize:!qq.ios(),uploading:j,uploadCors:r,uploadCustomHeaders:m,uploadNonMultipart:m,uploadViaPaste:q}}(),qq.isGenericPromise=function(a){"use strict";return!!(a&&a.then&&qq.isFunction(a.then))},qq.Promise=function(){"use strict";var a,b,c=[],d=[],e=[],f=0;qq.extend(this,{then:function(e,g){return 0===f?(e&&c.push(e),g&&d.push(g)):-1===f?g&&g.apply(null,b):e&&e.apply(null,a),this},done:function(c){return 0===f?e.push(c):c.apply(null,void 0===b?a:b),this},success:function(){return f=1,a=arguments,c.length&&qq.each(c,function(b,c){c.apply(null,a)}),e.length&&qq.each(e,function(b,c){c.apply(null,a)}),this},failure:function(){return f=-1,b=arguments,d.length&&qq.each(d,function(a,c){c.apply(null,b)}),e.length&&qq.each(e,function(a,c){c.apply(null,b)}),this}})},qq.BlobProxy=function(a,b){"use strict";qq.extend(this,{referenceBlob:a,create:function(){return b(a)}})},qq.UploadButton=function(a){"use strict";function b(){var a=document.createElement("input");return a.setAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME,d),a.setAttribute("title","file input"),e.setMultiple(g.multiple,a),g.folders&&qq.supportedFeatures.folderSelection&&a.setAttribute("webkitdirectory",""),g.acceptFiles&&a.setAttribute("accept",g.acceptFiles),a.setAttribute("type","file"),a.setAttribute("name",g.name),qq(a).css({position:"absolute",right:0,top:0,fontFamily:"Arial",fontSize:qq.ie()&&!qq.ie8()?"3500px":"118px",margin:0,padding:0,cursor:"pointer",opacity:0}),!qq.ie7()&&qq(a).css({height:"100%"}),g.element.appendChild(a),f.attach(a,"change",function(){g.onChange(a)}),f.attach(a,"mouseover",function(){qq(g.element).addClass(g.hoverClass)}),f.attach(a,"mouseout",function(){qq(g.element).removeClass(g.hoverClass)}),f.attach(a,"focus",function(){qq(g.element).addClass(g.focusClass)}),f.attach(a,"blur",function(){qq(g.element).removeClass(g.focusClass)}),a}var c,d,e=this,f=new qq.DisposeSupport,g={element:null,multiple:!1,acceptFiles:null,folders:!1,name:"qqfile",onChange:function(){},ios8BrowserCrashWorkaround:!1,hoverClass:"qq-upload-button-hover",focusClass:"qq-upload-button-focus"};qq.extend(g,a),d=qq.getUniqueId(),qq(g.element).css({position:"relative",overflow:"hidden",direction:"ltr"}),qq.extend(this,{getInput:function(){return c},getButtonId:function(){return d},setMultiple:function(a,b){var c=b||this.getInput();g.ios8BrowserCrashWorkaround&&qq.ios8()&&(qq.iosChrome()||qq.iosSafariWebView())?c.setAttribute("multiple",""):a?c.setAttribute("multiple",""):c.removeAttribute("multiple")},setAcceptFiles:function(a){a!==g.acceptFiles&&c.setAttribute("accept",a)},reset:function(){c.parentNode&&qq(c).remove(),qq(g.element).removeClass(g.focusClass),c=null,c=b()}}),c=b()},qq.UploadButton.BUTTON_ID_ATTR_NAME="qq-button-id",qq.UploadData=function(a){"use strict";function b(a){if(qq.isArray(a)){var b=[];return qq.each(a,function(a,c){b.push(e[c])}),b}return e[a]}function c(a){if(qq.isArray(a)){var b=[];return qq.each(a,function(a,c){b.push(e[f[c]])}),b}return e[f[a]]}function d(a){var b=[],c=[].concat(a);return qq.each(c,function(a,c){var d=g[c];void 0!==d&&qq.each(d,function(a,c){b.push(e[c])})}),b}var e=[],f={},g={},h={},i={};qq.extend(this,{addFile:function(b){var c=b.status||qq.status.SUBMITTING,d=e.push({name:b.name,originalName:b.name,uuid:b.uuid,size:null==b.size?-1:b.size,status:c})-1;return b.batchId&&(e[d].batchId=b.batchId,void 0===i[b.batchId]&&(i[b.batchId]=[]),i[b.batchId].push(d)),b.proxyGroupId&&(e[d].proxyGroupId=b.proxyGroupId,void 0===h[b.proxyGroupId]&&(h[b.proxyGroupId]=[]),h[b.proxyGroupId].push(d)),e[d].id=d,f[b.uuid]=d,void 0===g[c]&&(g[c]=[]),g[c].push(d),a.onStatusChange(d,null,c),d},retrieve:function(a){return qq.isObject(a)&&e.length?void 0!==a.id?b(a.id):void 0!==a.uuid?c(a.uuid):a.status?d(a.status):void 0:qq.extend([],e,!0)},reset:function(){e=[],f={},g={},i={}},setStatus:function(b,c){var d=e[b].status,f=qq.indexOf(g[d],b);g[d].splice(f,1),e[b].status=c,void 0===g[c]&&(g[c]=[]),g[c].push(b),a.onStatusChange(b,d,c)},uuidChanged:function(a,b){var c=e[a].uuid;e[a].uuid=b,f[b]=a,delete f[c]},updateName:function(a,b){e[a].name=b},updateSize:function(a,b){e[a].size=b},setParentId:function(a,b){e[a].parentId=b},getIdsInProxyGroup:function(a){var b=e[a].proxyGroupId;return b?h[b]:[]},getIdsInBatch:function(a){var b=e[a].batchId;return i[b]}})},qq.status={SUBMITTING:"submitting",SUBMITTED:"submitted",REJECTED:"rejected",QUEUED:"queued",CANCELED:"canceled",PAUSED:"paused",UPLOADING:"uploading",UPLOAD_RETRYING:"retrying upload",UPLOAD_SUCCESSFUL:"upload successful",UPLOAD_FAILED:"upload failed",DELETE_FAILED:"delete failed",DELETING:"deleting",DELETED:"deleted"},function(){"use strict";qq.basePublicApi={addBlobs:function(a,b,c){this.addFiles(a,b,c)},addFiles:function(a,b,c){this._maybeHandleIos8SafariWorkaround();var d=0===this._storedIds.length?qq.getUniqueId():this._currentBatchId,e=qq.bind(function(a){this._handleNewFile({blob:a,name:this._options.blobs.defaultName},d,l)},this),f=qq.bind(function(a){this._handleNewFile(a,d,l)},this),g=qq.bind(function(a){var b=qq.canvasToBlob(a);this._handleNewFile({blob:b,name:this._options.blobs.defaultName+".png"},d,l)},this),h=qq.bind(function(a){var b=a.quality&&a.quality/100,c=qq.canvasToBlob(a.canvas,a.type,b);this._handleNewFile({blob:c,name:a.name},d,l)},this),i=qq.bind(function(a){if(qq.isInput(a)&&qq.supportedFeatures.ajaxUploading){var b=Array.prototype.slice.call(a.files),c=this;qq.each(b,function(a,b){c._handleNewFile(b,d,l)})}else this._handleNewFile(a,d,l)},this),j=function(){qq.isFileList(a)&&(a=Array.prototype.slice.call(a)),a=[].concat(a)},k=this,l=[];this._currentBatchId=d,a&&(j(),qq.each(a,function(a,b){qq.isFileOrInput(b)?i(b):qq.isBlob(b)?e(b):qq.isObject(b)?b.blob&&b.name?f(b):b.canvas&&b.name&&h(b):b.tagName&&"canvas"===b.tagName.toLowerCase()?g(b):k.log(b+" is not a valid file container!  Ignoring!","warn")}),this.log("Received "+l.length+" files."),this._prepareItemsForUpload(l,b,c))},cancel:function(a){this._handler.cancel(a)},cancelAll:function(){var a=[],b=this;qq.extend(a,this._storedIds),qq.each(a,function(a,c){b.cancel(c)}),this._handler.cancelAll()},clearStoredFiles:function(){this._storedIds=[]},continueUpload:function(a){var b=this._uploadData.retrieve({id:a});return qq.supportedFeatures.pause&&this._options.chunking.enabled?b.status===qq.status.PAUSED?(this.log(qq.format("Paused file ID {} ({}) will be continued.  Not paused.",a,this.getName(a))),this._uploadFile(a),!0):(this.log(qq.format("Ignoring continue for file ID {} ({}).  Not paused.",a,this.getName(a)),"error"),!1):!1},deleteFile:function(a){return this._onSubmitDelete(a)},doesExist:function(a){return this._handler.isValid(a)},drawThumbnail:function(a,b,c,d){var e,f,g=new qq.Promise;return this._imageGenerator?(e=this._thumbnailUrls[a],f={scale:c>0,maxSize:c>0?c:null},!d&&qq.supportedFeatures.imagePreviews&&(e=this.getFile(a)),null==e?g.failure({container:b,error:"File or URL not found."}):this._imageGenerator.generate(e,b,f).then(function(a){g.success(a)},function(a,b){g.failure({container:a,error:b||"Problem generating thumbnail"})})):g.failure({container:b,error:"Missing image generator module"}),g},getButton:function(a){return this._getButton(this._buttonIdsForFileIds[a])},getEndpoint:function(a){return this._endpointStore.get(a)},getFile:function(a){return this._handler.getFile(a)||null},getInProgress:function(){return this._uploadData.retrieve({status:[qq.status.UPLOADING,qq.status.UPLOAD_RETRYING,qq.status.QUEUED]}).length},getName:function(a){return this._uploadData.retrieve({id:a}).name},getParentId:function(a){var b=this.getUploads({id:a}),c=null;return b&&void 0!==b.parentId&&(c=b.parentId),c},getResumableFilesData:function(){return this._handler.getResumableFilesData()},getSize:function(a){return this._uploadData.retrieve({id:a}).size},getNetUploads:function(){return this._netUploaded},getRemainingAllowedItems:function(){var a=this._currentItemLimit;return a>0?a-this._netUploadedOrQueued:null},getUploads:function(a){return this._uploadData.retrieve(a)},getUuid:function(a){return this._uploadData.retrieve({id:a}).uuid},log:function(a,b){!this._options.debug||b&&"info"!==b?b&&"info"!==b&&qq.log("[Fine Uploader "+qq.version+"] "+a,b):qq.log("[Fine Uploader "+qq.version+"] "+a)},pauseUpload:function(a){var b=this._uploadData.retrieve({id:a});if(!qq.supportedFeatures.pause||!this._options.chunking.enabled)return!1;if(qq.indexOf([qq.status.UPLOADING,qq.status.UPLOAD_RETRYING],b.status)>=0){if(this._handler.pause(a))return this._uploadData.setStatus(a,qq.status.PAUSED),!0;this.log(qq.format("Unable to pause file ID {} ({}).",a,this.getName(a)),"error")}else this.log(qq.format("Ignoring pause for file ID {} ({}).  Not in progress.",a,this.getName(a)),"error");return!1},reset:function(){this.log("Resetting uploader..."),this._handler.reset(),this._storedIds=[],this._autoRetries=[],this._retryTimeouts=[],this._preventRetries=[],this._thumbnailUrls=[],qq.each(this._buttons,function(a,b){b.reset()}),this._paramsStore.reset(),this._endpointStore.reset(),this._netUploadedOrQueued=0,this._netUploaded=0,this._uploadData.reset(),this._buttonIdsForFileIds=[],this._pasteHandler&&this._pasteHandler.reset(),this._options.session.refreshOnReset&&this._refreshSessionData(),this._succeededSinceLastAllComplete=[],this._failedSinceLastAllComplete=[],this._totalProgress&&this._totalProgress.reset()},retry:function(a){return this._manualRetry(a)},scaleImage:function(a,b){var c=this;return qq.Scaler.prototype.scaleImage(a,b,{log:qq.bind(c.log,c),getFile:qq.bind(c.getFile,c),uploadData:c._uploadData})},setCustomHeaders:function(a,b){this._customHeadersStore.set(a,b)},setDeleteFileCustomHeaders:function(a,b){this._deleteFileCustomHeadersStore.set(a,b)},setDeleteFileEndpoint:function(a,b){this._deleteFileEndpointStore.set(a,b)},setDeleteFileParams:function(a,b){this._deleteFileParamsStore.set(a,b)},setEndpoint:function(a,b){this._endpointStore.set(a,b)},setItemLimit:function(a){this._currentItemLimit=a},setName:function(a,b){this._uploadData.updateName(a,b)},setParams:function(a,b){this._paramsStore.set(a,b)},setUuid:function(a,b){return this._uploadData.uuidChanged(a,b)},uploadStoredFiles:function(){var a;if(0===this._storedIds.length)this._itemError("noFilesError");else for(;this._storedIds.length;)a=this._storedIds.shift(),this._uploadFile(a)}},qq.basePrivateApi={_addCannedFile:function(a){var b=this._uploadData.addFile({uuid:a.uuid,name:a.name,size:a.size,status:qq.status.UPLOAD_SUCCESSFUL});return a.deleteFileEndpoint&&this.setDeleteFileEndpoint(a.deleteFileEndpoint,b),a.deleteFileParams&&this.setDeleteFileParams(a.deleteFileParams,b),a.thumbnailUrl&&(this._thumbnailUrls[b]=a.thumbnailUrl),this._netUploaded++,this._netUploadedOrQueued++,b},_annotateWithButtonId:function(a,b){qq.isFile(a)&&(a.qqButtonId=this._getButtonId(b))},_batchError:function(a){this._options.callbacks.onError(null,null,a,void 0)},_createDeleteHandler:function(){var a=this;return new qq.DeleteFileAjaxRequester({method:this._options.deleteFile.method.toUpperCase(),maxConnections:this._options.maxConnections,uuidParamName:this._options.request.uuidName,customHeaders:this._deleteFileCustomHeadersStore,paramsStore:this._deleteFileParamsStore,endpointStore:this._deleteFileEndpointStore,cors:this._options.cors,log:qq.bind(a.log,a),onDelete:function(b){a._onDelete(b),a._options.callbacks.onDelete(b)},onDeleteComplete:function(b,c,d){a._onDeleteComplete(b,c,d),a._options.callbacks.onDeleteComplete(b,c,d)}})},_createPasteHandler:function(){var a=this;return new qq.PasteSupport({targetElement:this._options.paste.targetElement,callbacks:{log:qq.bind(a.log,a),pasteReceived:function(b){a._handleCheckedCallback({name:"onPasteReceived",callback:qq.bind(a._options.callbacks.onPasteReceived,a,b),onSuccess:qq.bind(a._handlePasteSuccess,a,b),identifier:"pasted image"})}}})},_createStore:function(a,b){var c={},d=a,e={},f=function(a){return qq.isObject(a)?qq.extend({},a):a},g=function(){return qq.isFunction(b)?b():b},h=function(a,c){b&&qq.isObject(c)&&qq.extend(c,g()),e[a]&&qq.extend(c,e[a])};return{set:function(a,b){null==b?(c={},d=f(a)):c[b]=f(a)},get:function(a){var b;return b=null!=a&&c[a]?c[a]:f(d),h(a,b),f(b)},addReadOnly:function(a,b){qq.isObject(c)&&(e[a]=e[a]||{},qq.extend(e[a],b))},remove:function(a){return delete c[a]},reset:function(){c={},e={},d=a}}},_createUploadDataTracker:function(){var a=this;return new qq.UploadData({getName:function(b){return a.getName(b)},getUuid:function(b){return a.getUuid(b)},getSize:function(b){return a.getSize(b)},onStatusChange:function(b,c,d){a._onUploadStatusChange(b,c,d),a._options.callbacks.onStatusChange(b,c,d),a._maybeAllComplete(b,d),a._totalProgress&&setTimeout(function(){a._totalProgress.onStatusChange(b,c,d)},0)}})},_createUploadButton:function(a){function b(){return qq.supportedFeatures.ajaxUploading?d._options.workarounds.iosEmptyVideos&&qq.ios()&&!qq.ios6()&&d._isAllowedExtension(f,".mov")?!1:void 0===a.multiple?d._options.multiple:a.multiple:!1}var c,d=this,e=a.accept||this._options.validation.acceptFiles,f=a.allowedExtensions||this._options.validation.allowedExtensions;return c=new qq.UploadButton({element:a.element,folders:a.folders,name:this._options.request.inputName,multiple:b(),acceptFiles:e,onChange:function(a){d._onInputChange(a)},hoverClass:this._options.classes.buttonHover,focusClass:this._options.classes.buttonFocus,ios8BrowserCrashWorkaround:this._options.workarounds.ios8BrowserCrash}),this._disposeSupport.addDisposer(function(){c.dispose()}),d._buttons.push(c),c},_createUploadHandler:function(a,b){var c=this,d={},e={debug:this._options.debug,maxConnections:this._options.maxConnections,cors:this._options.cors,paramsStore:this._paramsStore,endpointStore:this._endpointStore,chunking:this._options.chunking,resume:this._options.resume,blobs:this._options.blobs,log:qq.bind(c.log,c),preventRetryParam:this._options.retry.preventRetryResponseProperty,onProgress:function(a,b,e,f){0>e||0>f||(d[a]?(d[a].loaded!==e||d[a].total!==f)&&(c._onProgress(a,b,e,f),c._options.callbacks.onProgress(a,b,e,f)):(c._onProgress(a,b,e,f),c._options.callbacks.onProgress(a,b,e,f)),d[a]={loaded:e,total:f})},onComplete:function(a,b,e,f){delete d[a];var g,h=c.getUploads({id:a}).status;h!==qq.status.UPLOAD_SUCCESSFUL&&h!==qq.status.UPLOAD_FAILED&&(g=c._onComplete(a,b,e,f),g instanceof qq.Promise?g.done(function(){c._options.callbacks.onComplete(a,b,e,f)}):c._options.callbacks.onComplete(a,b,e,f))},onCancel:function(a,b,d){var e=new qq.Promise;return c._handleCheckedCallback({name:"onCancel",callback:qq.bind(c._options.callbacks.onCancel,c,a,b),onFailure:e.failure,onSuccess:function(){d.then(function(){c._onCancel(a,b)}),e.success()},identifier:a}),e},onUploadPrep:qq.bind(this._onUploadPrep,this),onUpload:function(a,b){c._onUpload(a,b),c._options.callbacks.onUpload(a,b)},onUploadChunk:function(a,b,d){c._onUploadChunk(a,d),c._options.callbacks.onUploadChunk(a,b,d)},onUploadChunkSuccess:function(){c._options.callbacks.onUploadChunkSuccess.apply(c,arguments)},onResume:function(a,b,d){return c._options.callbacks.onResume(a,b,d)},onAutoRetry:function(){return c._onAutoRetry.apply(c,arguments)},onUuidChanged:function(a,b){c.log("Server requested UUID change from '"+c.getUuid(a)+"' to '"+b+"'"),c.setUuid(a,b)},getName:qq.bind(c.getName,c),getUuid:qq.bind(c.getUuid,c),getSize:qq.bind(c.getSize,c),setSize:qq.bind(c._setSize,c),getDataByUuid:function(a){return c.getUploads({uuid:a})},isQueued:function(a){var b=c.getUploads({id:a}).status;return b===qq.status.QUEUED||b===qq.status.SUBMITTED||b===qq.status.UPLOAD_RETRYING||b===qq.status.PAUSED},getIdsInProxyGroup:c._uploadData.getIdsInProxyGroup,getIdsInBatch:c._uploadData.getIdsInBatch};return qq.each(this._options.request,function(a,b){e[a]=b}),e.customHeaders=this._customHeadersStore,a&&qq.each(a,function(a,b){e[a]=b}),new qq.UploadHandlerController(e,b)},_fileOrBlobRejected:function(a){this._netUploadedOrQueued--,this._uploadData.setStatus(a,qq.status.REJECTED)},_formatSize:function(a){var b=-1;do a/=1e3,b++;while(a>999);return Math.max(a,.1).toFixed(1)+this._options.text.sizeSymbols[b]},_generateExtraButtonSpecs:function(){var a=this;this._extraButtonSpecs={},qq.each(this._options.extraButtons,function(b,c){var d=c.multiple,e=qq.extend({},a._options.validation,!0),f=qq.extend({},c);void 0===d&&(d=a._options.multiple),f.validation&&qq.extend(e,c.validation,!0),qq.extend(f,{multiple:d,validation:e},!0),a._initExtraButton(f)})},_getButton:function(a){var b=this._extraButtonSpecs[a];return b?b.element:a===this._defaultButtonId?this._options.button:void 0},_getButtonId:function(a){var b,c,d=a;if(d instanceof qq.BlobProxy&&(d=d.referenceBlob),d&&!qq.isBlob(d)){if(qq.isFile(d))return d.qqButtonId;if("input"===d.tagName.toLowerCase()&&"file"===d.type.toLowerCase())return d.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);if(b=d.getElementsByTagName("input"),qq.each(b,function(a,b){return"file"===b.getAttribute("type")?(c=b,!1):void 0}),c)return c.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME)}},_getNotFinished:function(){return this._uploadData.retrieve({status:[qq.status.UPLOADING,qq.status.UPLOAD_RETRYING,qq.status.QUEUED,qq.status.SUBMITTING,qq.status.SUBMITTED,qq.status.PAUSED]}).length},_getValidationBase:function(a){var b=this._extraButtonSpecs[a];return b?b.validation:this._options.validation},_getValidationDescriptor:function(a){return a.file instanceof qq.BlobProxy?{name:qq.getFilename(a.file.referenceBlob),size:a.file.referenceBlob.size}:{name:this.getUploads({id:a.id}).name,size:this.getUploads({id:a.id}).size}},_getValidationDescriptors:function(a){var b=this,c=[];return qq.each(a,function(a,d){c.push(b._getValidationDescriptor(d))}),c},_handleCameraAccess:function(){if(this._options.camera.ios&&qq.ios()){var a="image/*;capture=camera",b=this._options.camera.button,c=b?this._getButtonId(b):this._defaultButtonId,d=this._options;c&&c!==this._defaultButtonId&&(d=this._extraButtonSpecs[c]),d.multiple=!1,null===d.validation.acceptFiles?d.validation.acceptFiles=a:d.validation.acceptFiles+=","+a,qq.each(this._buttons,function(a,b){return b.getButtonId()===c?(b.setMultiple(d.multiple),b.setAcceptFiles(d.acceptFiles),!1):void 0})}},_handleCheckedCallback:function(a){var b=this,c=a.callback();return qq.isGenericPromise(c)?(this.log(a.name+" - waiting for "+a.name+" promise to be fulfilled for "+a.identifier),c.then(function(c){b.log(a.name+" promise success for "+a.identifier),a.onSuccess(c)},function(){a.onFailure?(b.log(a.name+" promise failure for "+a.identifier),a.onFailure()):b.log(a.name+" promise failure for "+a.identifier)})):(c!==!1?a.onSuccess(c):a.onFailure?(this.log(a.name+" - return value was 'false' for "+a.identifier+".  Invoking failure callback."),a.onFailure()):this.log(a.name+" - return value was 'false' for "+a.identifier+".  Will not proceed."),c)},_handleNewFile:function(a,b,c){var d=this,e=qq.getUniqueId(),f=-1,g=qq.getFilename(a),h=a.blob||a,i=this._customNewFileHandler?this._customNewFileHandler:qq.bind(d._handleNewFileGeneric,d);!qq.isInput(h)&&h.size>=0&&(f=h.size),i(h,g,e,f,c,b,this._options.request.uuidName,{uploadData:d._uploadData,paramsStore:d._paramsStore,addFileToHandler:function(a,b){d._handler.add(a,b),d._netUploadedOrQueued++,d._trackButton(a)}})},_handleNewFileGeneric:function(a,b,c,d,e,f){var g=this._uploadData.addFile({uuid:c,name:b,size:d,batchId:f});this._handler.add(g,a),this._trackButton(g),this._netUploadedOrQueued++,e.push({id:g,file:a})},_handlePasteSuccess:function(a,b){var c=a.type.split("/")[1],d=b;null==d&&(d=this._options.paste.defaultName),d+="."+c,this.addFiles({name:d,blob:a})},_initExtraButton:function(a){var b=this._createUploadButton({element:a.element,multiple:a.multiple,accept:a.validation.acceptFiles,folders:a.folders,allowedExtensions:a.validation.allowedExtensions});this._extraButtonSpecs[b.getButtonId()]=a},_initFormSupportAndParams:function(){this._formSupport=qq.FormSupport&&new qq.FormSupport(this._options.form,qq.bind(this.uploadStoredFiles,this),qq.bind(this.log,this)),this._formSupport&&this._formSupport.attachedToForm?(this._paramsStore=this._createStore(this._options.request.params,this._formSupport.getFormInputsAsObject),this._options.autoUpload=this._formSupport.newAutoUpload,this._formSupport.newEndpoint&&(this._options.request.endpoint=this._formSupport.newEndpoint)):this._paramsStore=this._createStore(this._options.request.params)
+},_isDeletePossible:function(){return qq.DeleteFileAjaxRequester&&this._options.deleteFile.enabled?this._options.cors.expected?qq.supportedFeatures.deleteFileCorsXhr?!0:qq.supportedFeatures.deleteFileCorsXdr&&this._options.cors.allowXdr?!0:!1:!0:!1},_isAllowedExtension:function(a,b){var c=!1;return a.length?(qq.each(a,function(a,d){if(qq.isString(d)){var e=new RegExp("\\."+d+"$","i");if(null!=b.match(e))return c=!0,!1}}),c):!0},_itemError:function(a,b,c){function d(a,b){g=g.replace(a,b)}var e,f,g=this._options.messages[a],h=[],i=[].concat(b),j=i[0],k=this._getButtonId(c),l=this._getValidationBase(k);return qq.each(l.allowedExtensions,function(a,b){qq.isString(b)&&h.push(b)}),e=h.join(", ").toLowerCase(),d("{file}",this._options.formatFileName(j)),d("{extensions}",e),d("{sizeLimit}",this._formatSize(l.sizeLimit)),d("{minSizeLimit}",this._formatSize(l.minSizeLimit)),f=g.match(/(\{\w+\})/g),null!==f&&qq.each(f,function(a,b){d(b,i[a])}),this._options.callbacks.onError(null,j,g,void 0),g},_manualRetry:function(a,b){return this._onBeforeManualRetry(a)?(this._netUploadedOrQueued++,this._uploadData.setStatus(a,qq.status.UPLOAD_RETRYING),b?b(a):this._handler.retry(a),!0):void 0},_maybeAllComplete:function(a,b){var c=this,d=this._getNotFinished();b===qq.status.UPLOAD_SUCCESSFUL?this._succeededSinceLastAllComplete.push(a):b===qq.status.UPLOAD_FAILED&&this._failedSinceLastAllComplete.push(a),0===d&&(this._succeededSinceLastAllComplete.length||this._failedSinceLastAllComplete.length)&&setTimeout(function(){c._onAllComplete(c._succeededSinceLastAllComplete,c._failedSinceLastAllComplete)},0)},_maybeHandleIos8SafariWorkaround:function(){var a=this;if(this._options.workarounds.ios8SafariUploads&&qq.ios800()&&qq.iosSafari())throw setTimeout(function(){window.alert(a._options.messages.unsupportedBrowserIos8Safari)},0),new qq.Error(this._options.messages.unsupportedBrowserIos8Safari)},_maybeParseAndSendUploadError:function(a,b,c,d){if(!c.success)if(d&&200!==d.status&&!c.error)this._options.callbacks.onError(a,b,"XHR returned response code "+d.status,d);else{var e=c.error?c.error:this._options.text.defaultResponseError;this._options.callbacks.onError(a,b,e,d)}},_maybeProcessNextItemAfterOnValidateCallback:function(a,b,c,d,e){var f=this;if(b.length>c)if(a||!this._options.validation.stopOnFirstInvalidFile)setTimeout(function(){var a=f._getValidationDescriptor(b[c]),g=f._getButtonId(b[c].file),h=f._getButton(g);f._handleCheckedCallback({name:"onValidate",callback:qq.bind(f._options.callbacks.onValidate,f,a,h),onSuccess:qq.bind(f._onValidateCallbackSuccess,f,b,c,d,e),onFailure:qq.bind(f._onValidateCallbackFailure,f,b,c,d,e),identifier:"Item '"+a.name+"', size: "+a.size})},0);else if(!a)for(;c<b.length;c++)f._fileOrBlobRejected(b[c].id)},_onAllComplete:function(a,b){this._totalProgress&&this._totalProgress.onAllComplete(a,b,this._preventRetries),this._options.callbacks.onAllComplete(qq.extend([],a),qq.extend([],b)),this._succeededSinceLastAllComplete=[],this._failedSinceLastAllComplete=[]},_onAutoRetry:function(a,b,c,d,e){var f=this;return f._preventRetries[a]=c[f._options.retry.preventRetryResponseProperty],f._shouldAutoRetry(a,b,c)?(f._maybeParseAndSendUploadError.apply(f,arguments),f._options.callbacks.onAutoRetry(a,b,f._autoRetries[a]),f._onBeforeAutoRetry(a,b),f._retryTimeouts[a]=setTimeout(function(){f.log("Retrying "+b+"..."),f._uploadData.setStatus(a,qq.status.UPLOAD_RETRYING),e?e(a):f._handler.retry(a)},1e3*f._options.retry.autoAttemptDelay),!0):void 0},_onBeforeAutoRetry:function(a,b){this.log("Waiting "+this._options.retry.autoAttemptDelay+" seconds before retrying "+b+"...")},_onBeforeManualRetry:function(a){var b,c=this._currentItemLimit;return this._preventRetries[a]?(this.log("Retries are forbidden for id "+a,"warn"),!1):this._handler.isValid(a)?(b=this.getName(a),this._options.callbacks.onManualRetry(a,b)===!1?!1:c>0&&this._netUploadedOrQueued+1>c?(this._itemError("retryFailTooManyItems"),!1):(this.log("Retrying upload for '"+b+"' (id: "+a+")..."),!0)):(this.log("'"+a+"' is not a valid file ID","error"),!1)},_onCancel:function(a){this._netUploadedOrQueued--,clearTimeout(this._retryTimeouts[a]);var b=qq.indexOf(this._storedIds,a);!this._options.autoUpload&&b>=0&&this._storedIds.splice(b,1),this._uploadData.setStatus(a,qq.status.CANCELED)},_onComplete:function(a,b,c,d){return c.success?(c.thumbnailUrl&&(this._thumbnailUrls[a]=c.thumbnailUrl),this._netUploaded++,this._uploadData.setStatus(a,qq.status.UPLOAD_SUCCESSFUL)):(this._netUploadedOrQueued--,this._uploadData.setStatus(a,qq.status.UPLOAD_FAILED),c[this._options.retry.preventRetryResponseProperty]===!0&&(this._preventRetries[a]=!0)),this._maybeParseAndSendUploadError(a,b,c,d),c.success?!0:!1},_onDelete:function(a){this._uploadData.setStatus(a,qq.status.DELETING)},_onDeleteComplete:function(a,b,c){var d=this.getName(a);c?(this._uploadData.setStatus(a,qq.status.DELETE_FAILED),this.log("Delete request for '"+d+"' has failed.","error"),void 0===b.withCredentials?this._options.callbacks.onError(a,d,"Delete request failed",b):this._options.callbacks.onError(a,d,"Delete request failed with response code "+b.status,b)):(this._netUploadedOrQueued--,this._netUploaded--,this._handler.expunge(a),this._uploadData.setStatus(a,qq.status.DELETED),this.log("Delete request for '"+d+"' has succeeded."))},_onInputChange:function(a){var b;if(qq.supportedFeatures.ajaxUploading){for(b=0;b<a.files.length;b++)this._annotateWithButtonId(a.files[b],a);this.addFiles(a.files)}else a.value.length>0&&this.addFiles(a);qq.each(this._buttons,function(a,b){b.reset()})},_onProgress:function(a,b,c,d){this._totalProgress&&this._totalProgress.onIndividualProgress(a,c,d)},_onSubmit:function(){},_onSubmitCallbackSuccess:function(a){this._onSubmit.apply(this,arguments),this._uploadData.setStatus(a,qq.status.SUBMITTED),this._onSubmitted.apply(this,arguments),this._options.callbacks.onSubmitted.apply(this,arguments),this._options.autoUpload?this._uploadFile(a):this._storeForLater(a)},_onSubmitDelete:function(a,b,c){var d,e=this.getUuid(a);return b&&(d=qq.bind(b,this,a,e,c)),this._isDeletePossible()?(this._handleCheckedCallback({name:"onSubmitDelete",callback:qq.bind(this._options.callbacks.onSubmitDelete,this,a),onSuccess:d||qq.bind(this._deleteHandler.sendDelete,this,a,e,c),identifier:a}),!0):(this.log("Delete request ignored for ID "+a+", delete feature is disabled or request not possible "+"due to CORS on a user agent that does not support pre-flighting.","warn"),!1)},_onSubmitted:function(){},_onTotalProgress:function(a,b){this._options.callbacks.onTotalProgress(a,b)},_onUploadPrep:function(){},_onUpload:function(a){this._uploadData.setStatus(a,qq.status.UPLOADING)},_onUploadChunk:function(){},_onUploadStatusChange:function(a,b,c){c===qq.status.PAUSED&&clearTimeout(this._retryTimeouts[a])},_onValidateBatchCallbackFailure:function(a){var b=this;qq.each(a,function(a,c){b._fileOrBlobRejected(c.id)})},_onValidateBatchCallbackSuccess:function(a,b,c,d,e){var f,g=this._currentItemLimit,h=this._netUploadedOrQueued;0===g||g>=h?b.length>0?this._handleCheckedCallback({name:"onValidate",callback:qq.bind(this._options.callbacks.onValidate,this,a[0],e),onSuccess:qq.bind(this._onValidateCallbackSuccess,this,b,0,c,d),onFailure:qq.bind(this._onValidateCallbackFailure,this,b,0,c,d),identifier:"Item '"+b[0].file.name+"', size: "+b[0].file.size}):this._itemError("noFilesError"):(this._onValidateBatchCallbackFailure(b),f=this._options.messages.tooManyItemsError.replace(/\{netItems\}/g,h).replace(/\{itemLimit\}/g,g),this._batchError(f))},_onValidateCallbackFailure:function(a,b,c,d){var e=b+1;this._fileOrBlobRejected(a[b].id,a[b].file.name),this._maybeProcessNextItemAfterOnValidateCallback(!1,a,e,c,d)},_onValidateCallbackSuccess:function(a,b,c,d){var e=this,f=b+1,g=this._getValidationDescriptor(a[b]);this._validateFileOrBlobData(a[b],g).then(function(){e._upload(a[b].id,c,d),e._maybeProcessNextItemAfterOnValidateCallback(!0,a,f,c,d)},function(){e._maybeProcessNextItemAfterOnValidateCallback(!1,a,f,c,d)})},_prepareItemsForUpload:function(a,b,c){if(0===a.length)return this._itemError("noFilesError"),void 0;var d=this._getValidationDescriptors(a),e=this._getButtonId(a[0].file),f=this._getButton(e);this._handleCheckedCallback({name:"onValidateBatch",callback:qq.bind(this._options.callbacks.onValidateBatch,this,d,f),onSuccess:qq.bind(this._onValidateBatchCallbackSuccess,this,d,a,b,c,f),onFailure:qq.bind(this._onValidateBatchCallbackFailure,this,a),identifier:"batch validation"})},_preventLeaveInProgress:function(){var a=this;this._disposeSupport.attach(window,"beforeunload",function(b){return a.getInProgress()?(b=b||window.event,b.returnValue=a._options.messages.onLeave,a._options.messages.onLeave):void 0})},_refreshSessionData:function(){var a=this,b=this._options.session;qq.Session&&null!=this._options.session.endpoint&&(this._session||(qq.extend(b,this._options.cors),b.log=qq.bind(this.log,this),b.addFileRecord=qq.bind(this._addCannedFile,this),this._session=new qq.Session(b)),setTimeout(function(){a._session.refresh().then(function(b,c){a._options.callbacks.onSessionRequestComplete(b,!0,c)},function(b,c){a._options.callbacks.onSessionRequestComplete(b,!1,c)})},0))},_setSize:function(a,b){this._uploadData.updateSize(a,b),this._totalProgress&&this._totalProgress.onNewSize(a)},_shouldAutoRetry:function(a){var b=this._uploadData.retrieve({id:a});return!this._preventRetries[a]&&this._options.retry.enableAuto&&b.status!==qq.status.PAUSED&&(void 0===this._autoRetries[a]&&(this._autoRetries[a]=0),this._autoRetries[a]<this._options.retry.maxAutoAttempts)?(this._autoRetries[a]+=1,!0):!1},_storeForLater:function(a){this._storedIds.push(a)},_trackButton:function(a){var b;b=qq.supportedFeatures.ajaxUploading?this._handler.getFile(a).qqButtonId:this._getButtonId(this._handler.getInput(a)),b&&(this._buttonIdsForFileIds[a]=b)},_upload:function(a,b,c){var d=this.getName(a);b&&this.setParams(b,a),c&&this.setEndpoint(c,a),this._handleCheckedCallback({name:"onSubmit",callback:qq.bind(this._options.callbacks.onSubmit,this,a,d),onSuccess:qq.bind(this._onSubmitCallbackSuccess,this,a,d),onFailure:qq.bind(this._fileOrBlobRejected,this,a,d),identifier:a})},_uploadFile:function(a){this._handler.upload(a)||this._uploadData.setStatus(a,qq.status.QUEUED)},_validateFileOrBlobData:function(a,b){var c=this,d=function(){return a.file instanceof qq.BlobProxy?a.file.referenceBlob:a.file}(),e=b.name,f=b.size,g=this._getButtonId(a.file),h=this._getValidationBase(g),i=new qq.Promise;return i.then(function(){},function(){c._fileOrBlobRejected(a.id,e)}),qq.isFileOrInput(d)&&!this._isAllowedExtension(h.allowedExtensions,e)?(this._itemError("typeError",e,d),i.failure()):0===f?(this._itemError("emptyError",e,d),i.failure()):f>0&&h.sizeLimit&&f>h.sizeLimit?(this._itemError("sizeError",e,d),i.failure()):f>0&&f<h.minSizeLimit?(this._itemError("minSizeError",e,d),i.failure()):(qq.ImageValidation&&qq.supportedFeatures.imagePreviews&&qq.isFile(d)?new qq.ImageValidation(d,qq.bind(c.log,c)).validate(h.image).then(i.success,function(a){c._itemError(a+"ImageError",e,d),i.failure()}):i.success(),i)},_wrapCallbacks:function(){var a,b,c;a=this,b=function(b,c,d){var e;try{return c.apply(a,d)}catch(f){e=f.message||f.toString(),a.log("Caught exception in '"+b+"' callback - "+e,"error")}};for(c in this._options.callbacks)!function(){var d,e;d=c,e=a._options.callbacks[d],a._options.callbacks[d]=function(){return b(d,e,arguments)}}()}}}(),function(){"use strict";qq.FineUploaderBasic=function(a){var b=this;this._options={debug:!1,button:null,multiple:!0,maxConnections:3,disableCancelForFormUploads:!1,autoUpload:!0,request:{customHeaders:{},endpoint:"/server/upload",filenameParam:"qqfilename",forceMultipart:!0,inputName:"qqfile",method:"POST",params:{},paramsInBody:!0,totalFileSizeName:"qqtotalfilesize",uuidName:"qquuid"},validation:{allowedExtensions:[],sizeLimit:0,minSizeLimit:0,itemLimit:0,stopOnFirstInvalidFile:!0,acceptFiles:null,image:{maxHeight:0,maxWidth:0,minHeight:0,minWidth:0}},callbacks:{onSubmit:function(){},onSubmitted:function(){},onComplete:function(){},onAllComplete:function(){},onCancel:function(){},onUpload:function(){},onUploadChunk:function(){},onUploadChunkSuccess:function(){},onResume:function(){},onProgress:function(){},onTotalProgress:function(){},onError:function(){},onAutoRetry:function(){},onManualRetry:function(){},onValidateBatch:function(){},onValidate:function(){},onSubmitDelete:function(){},onDelete:function(){},onDeleteComplete:function(){},onPasteReceived:function(){},onStatusChange:function(){},onSessionRequestComplete:function(){}},messages:{typeError:"{file} has an invalid extension. Valid extension(s): {extensions}.",sizeError:"{file} is too large, maximum file size is {sizeLimit}.",minSizeError:"{file} is too small, minimum file size is {minSizeLimit}.",emptyError:"{file} is empty, please select files again without it.",noFilesError:"No files to upload.",tooManyItemsError:"Too many items ({netItems}) would be uploaded.  Item limit is {itemLimit}.",maxHeightImageError:"Image is too tall.",maxWidthImageError:"Image is too wide.",minHeightImageError:"Image is not tall enough.",minWidthImageError:"Image is not wide enough.",retryFailTooManyItems:"Retry failed - you have reached your file limit.",onLeave:"The files are being uploaded, if you leave now the upload will be canceled.",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."},retry:{enableAuto:!1,maxAutoAttempts:3,autoAttemptDelay:5,preventRetryResponseProperty:"preventRetry"},classes:{buttonHover:"qq-upload-button-hover",buttonFocus:"qq-upload-button-focus"},chunking:{enabled:!1,concurrent:{enabled:!1},mandatory:!1,paramNames:{partIndex:"qqpartindex",partByteOffset:"qqpartbyteoffset",chunkSize:"qqchunksize",totalFileSize:"qqtotalfilesize",totalParts:"qqtotalparts"},partSize:2e6,success:{endpoint:null}},resume:{enabled:!1,recordsExpireIn:7,paramNames:{resuming:"qqresume"}},formatFileName:function(a){return a},text:{defaultResponseError:"Upload failure reason unknown",sizeSymbols:["kB","MB","GB","TB","PB","EB"]},deleteFile:{enabled:!1,method:"DELETE",endpoint:"/server/upload",customHeaders:{},params:{}},cors:{expected:!1,sendCredentials:!1,allowXdr:!1},blobs:{defaultName:"misc_data"},paste:{targetElement:null,defaultName:"pasted_image"},camera:{ios:!1,button:null},extraButtons:[],session:{endpoint:null,params:{},customHeaders:{},refreshOnReset:!0},form:{element:"qq-form",autoUpload:!1,interceptSubmit:!0},scaling:{sendOriginal:!0,orient:!0,defaultType:null,defaultQuality:80,failureText:"Failed to scale",includeExif:!1,sizes:[]},workarounds:{iosEmptyVideos:!0,ios8SafariUploads:!0,ios8BrowserCrash:!1}},qq.extend(this._options,a,!0),this._buttons=[],this._extraButtonSpecs={},this._buttonIdsForFileIds=[],this._wrapCallbacks(),this._disposeSupport=new qq.DisposeSupport,this._storedIds=[],this._autoRetries=[],this._retryTimeouts=[],this._preventRetries=[],this._thumbnailUrls=[],this._netUploadedOrQueued=0,this._netUploaded=0,this._uploadData=this._createUploadDataTracker(),this._initFormSupportAndParams(),this._customHeadersStore=this._createStore(this._options.request.customHeaders),this._deleteFileCustomHeadersStore=this._createStore(this._options.deleteFile.customHeaders),this._deleteFileParamsStore=this._createStore(this._options.deleteFile.params),this._endpointStore=this._createStore(this._options.request.endpoint),this._deleteFileEndpointStore=this._createStore(this._options.deleteFile.endpoint),this._handler=this._createUploadHandler(),this._deleteHandler=qq.DeleteFileAjaxRequester&&this._createDeleteHandler(),this._options.button&&(this._defaultButtonId=this._createUploadButton({element:this._options.button}).getButtonId()),this._generateExtraButtonSpecs(),this._handleCameraAccess(),this._options.paste.targetElement&&(qq.PasteSupport?this._pasteHandler=this._createPasteHandler():this.log("Paste support module not found","error")),this._preventLeaveInProgress(),this._imageGenerator=qq.ImageGenerator&&new qq.ImageGenerator(qq.bind(this.log,this)),this._refreshSessionData(),this._succeededSinceLastAllComplete=[],this._failedSinceLastAllComplete=[],this._scaler=qq.Scaler&&new qq.Scaler(this._options.scaling,qq.bind(this.log,this))||{},this._scaler.enabled&&(this._customNewFileHandler=qq.bind(this._scaler.handleNewFile,this._scaler)),qq.TotalProgress&&qq.supportedFeatures.progressBar&&(this._totalProgress=new qq.TotalProgress(qq.bind(this._onTotalProgress,this),function(a){var c=b._uploadData.retrieve({id:a});return c&&c.size||0})),this._currentItemLimit=this._options.validation.itemLimit},qq.FineUploaderBasic.prototype=qq.basePublicApi,qq.extend(qq.FineUploaderBasic.prototype,qq.basePrivateApi)}(),qq.AjaxRequester=function(a){"use strict";function b(){return qq.indexOf(["GET","POST","HEAD"],w.method)>=0}function c(){var a=!1;return qq.each(a,function(b,c){return qq.indexOf(["Accept","Accept-Language","Content-Language","Content-Type"],c)<0?(a=!0,!1):void 0}),a}function d(a){return w.cors.expected&&void 0===a.withCredentials}function e(){var a;return(window.XMLHttpRequest||window.ActiveXObject)&&(a=qq.createXhrInstance(),void 0===a.withCredentials&&(a=new XDomainRequest)),a}function f(a,b){var c=v[a].xhr;return c||(c=b?b:w.cors.expected?e():qq.createXhrInstance(),v[a].xhr=c),c}function g(a){var b,c=qq.indexOf(u,a),d=w.maxConnections;delete v[a],u.splice(c,1),u.length>=d&&d>c&&(b=u[d-1],j(b))}function h(a,b){var c=f(a),e=w.method,h=b===!0;g(a),h?s(e+" request for "+a+" has failed","error"):d(c)||q(c.status)||(h=!0,s(e+" request for "+a+" has failed - response code "+c.status,"error")),w.onComplete(a,c,h)}function i(a){var b,c=v[a].additionalParams,d=w.mandatedParams;return w.paramsStore.get&&(b=w.paramsStore.get(a)),c&&qq.each(c,function(a,c){b=b||{},b[a]=c}),d&&qq.each(d,function(a,c){b=b||{},b[a]=c}),b}function j(a,b){var c,e=f(a,b),g=w.method,h=i(a),j=v[a].payload;return w.onSend(a),c=k(a,h),d(e)?(e.onload=n(a),e.onerror=o(a)):e.onreadystatechange=l(a),m(a),e.open(g,c,!0),w.cors.expected&&w.cors.sendCredentials&&!d(e)&&(e.withCredentials=!0),p(a),s("Sending "+g+" request for "+a),j?e.send(j):t||!h?e.send():h&&w.contentType&&w.contentType.toLowerCase().indexOf("application/x-www-form-urlencoded")>=0?e.send(qq.obj2url(h,"")):h&&w.contentType&&w.contentType.toLowerCase().indexOf("application/json")>=0?e.send(JSON.stringify(h)):e.send(h),e}function k(a,b){var c=w.endpointStore.get(a),d=v[a].addToPath;return void 0!=d&&(c+="/"+d),t&&b?qq.obj2url(b,c):c}function l(a){return function(){4===f(a).readyState&&h(a)}}function m(a){var b=w.onProgress;b&&(f(a).upload.onprogress=function(c){c.lengthComputable&&b(a,c.loaded,c.total)})}function n(a){return function(){h(a)}}function o(a){return function(){h(a,!0)}}function p(a){var e=f(a),g=w.customHeaders,h=v[a].additionalHeaders||{},i=w.method,j={};d(e)||(w.acceptHeader&&e.setRequestHeader("Accept",w.acceptHeader),w.allowXRequestedWithAndCacheControl&&(w.cors.expected&&b()&&!c(g)||(e.setRequestHeader("X-Requested-With","XMLHttpRequest"),e.setRequestHeader("Cache-Control","no-cache"))),!w.contentType||"POST"!==i&&"PUT"!==i||e.setRequestHeader("Content-Type",w.contentType),qq.extend(j,qq.isFunction(g)?g(a):g),qq.extend(j,h),qq.each(j,function(a,b){e.setRequestHeader(a,b)}))}function q(a){return qq.indexOf(w.successfulResponseCodes[w.method],a)>=0}function r(a,b,c,d,e,f){v[a]={addToPath:c,additionalParams:d,additionalHeaders:e,payload:f};var g=u.push(a);return g<=w.maxConnections?j(a,b):void 0}var s,t,u=[],v={},w={acceptHeader:null,validMethods:["PATCH","POST","PUT"],method:"POST",contentType:"application/x-www-form-urlencoded",maxConnections:3,customHeaders:{},endpointStore:{},paramsStore:{},mandatedParams:{},allowXRequestedWithAndCacheControl:!0,successfulResponseCodes:{DELETE:[200,202,204],PATCH:[200,201,202,203,204],POST:[200,201,202,203,204],PUT:[200,201,202,203,204],GET:[200]},cors:{expected:!1,sendCredentials:!1},log:function(){},onSend:function(){},onComplete:function(){},onProgress:null};if(qq.extend(w,a),s=w.log,qq.indexOf(w.validMethods,w.method)<0)throw new Error("'"+w.method+"' is not a supported method for this type of request!");t="GET"===w.method||"DELETE"===w.method,qq.extend(this,{initTransport:function(a){var b,c,d,e,f;return{withPath:function(a){return b=a,this},withParams:function(a){return c=a,this},withHeaders:function(a){return d=a,this},withPayload:function(a){return e=a,this},withCacheBuster:function(){return f=!0,this},send:function(g){return f&&qq.indexOf(["GET","DELETE"],w.method)>=0&&(c.qqtimestamp=(new Date).getTime()),r(a,g,b,c,d,e)}}},canceled:function(a){g(a)}})},qq.UploadHandler=function(a){"use strict";var b=a.proxy,c={},d=b.onCancel,e=b.getName;qq.extend(this,{add:function(a,b){c[a]=b,c[a].temp={}},cancel:function(a){var b=this,f=new qq.Promise,g=d(a,e(a),f);g.then(function(){b.isValid(a)&&(c[a].canceled=!0,b.expunge(a)),f.success()})},expunge:function(a){delete c[a]},getThirdPartyFileId:function(a){return c[a].key},isValid:function(a){return void 0!==c[a]},reset:function(){c={}},_getFileState:function(a){return c[a]},_setThirdPartyFileId:function(a,b){c[a].key=b},_wasCanceled:function(a){return!!c[a].canceled}})},qq.UploadHandlerController=function(a,b){"use strict";var c,d,e,f=this,g=!1,h=!1,i={paramsStore:{},maxConnections:3,chunking:{enabled:!1,multiple:{enabled:!1}},log:function(){},onProgress:function(){},onComplete:function(){},onCancel:function(){},onUploadPrep:function(){},onUpload:function(){},onUploadChunk:function(){},onUploadChunkSuccess:function(){},onAutoRetry:function(){},onResume:function(){},onUuidChanged:function(){},getName:function(){},setSize:function(){},isQueued:function(){},getIdsInProxyGroup:function(){},getIdsInBatch:function(){}},j={done:function(a,b,c,d){var f=e._getChunkData(a,b);e._getFileState(a).attemptingResume=!1,delete e._getFileState(a).temp.chunkProgress[b],e._getFileState(a).loaded+=f.size,i.onUploadChunkSuccess(a,e._getChunkDataForCallback(f),c,d)},finalize:function(a){var b=i.getSize(a),c=i.getName(a);d("All chunks have been uploaded for "+a+" - finalizing...."),e.finalizeChunks(a).then(function(f,g){d("Finalize successful for "+a);var h=m.normalizeResponse(f,!0);i.onProgress(a,c,b,b),e._maybeDeletePersistedChunkData(a),m.cleanup(a,h,g)},function(b,e){var f=m.normalizeResponse(b,!1);d("Problem finalizing chunks for file ID "+a+" - "+f.error,"error"),f.reset&&j.reset(a),i.onAutoRetry(a,c,f,e)||m.cleanup(a,f,e)})},hasMoreParts:function(a){return!!e._getFileState(a).chunking.remaining.length},nextPart:function(a){var b=e._getFileState(a).chunking.remaining.shift();return b>=e._getTotalChunks(a)&&(b=null),b},reset:function(a){d("Server or callback has ordered chunking effort to be restarted on next attempt for item ID "+a,"error"),e._maybeDeletePersistedChunkData(a),e.reevaluateChunking(a),e._getFileState(a).loaded=0},sendNext:function(a){var b=i.getSize(a),c=i.getName(a),f=j.nextPart(a),g=e._getChunkData(a,f),l=e._getFileState(a).attemptingResume,n=e._getFileState(a).chunking.inProgress||[];null==e._getFileState(a).loaded&&(e._getFileState(a).loaded=0),l&&i.onResume(a,c,g)===!1&&(j.reset(a),f=j.nextPart(a),g=e._getChunkData(a,f),l=!1),null==f&&0===n.length?j.finalize(a):(d("Sending chunked upload request for item "+a+": bytes "+(g.start+1)+"-"+g.end+" of "+b),i.onUploadChunk(a,c,e._getChunkDataForCallback(g)),n.push(f),e._getFileState(a).chunking.inProgress=n,h&&k.open(a,f),h&&k.available()&&e._getFileState(a).chunking.remaining.length&&j.sendNext(a),e.uploadChunk(a,f,l).then(function(b,c){d("Chunked upload request succeeded for "+a+", chunk "+f),e.clearCachedChunk(a,f);var g=e._getFileState(a).chunking.inProgress||[],h=m.normalizeResponse(b,!0),i=qq.indexOf(g,f);d(qq.format("Chunk {} for file {} uploaded successfully.",f,a)),j.done(a,f,h,c),i>=0&&g.splice(i,1),e._maybePersistChunkedState(a),j.hasMoreParts(a)||0!==g.length?j.hasMoreParts(a)&&j.sendNext(a):j.finalize(a)},function(b,g){d("Chunked upload request failed for "+a+", chunk "+f),e.clearCachedChunk(a,f);var l,n=m.normalizeResponse(b,!1);n.reset?j.reset(a):(l=qq.indexOf(e._getFileState(a).chunking.inProgress,f),l>=0&&(e._getFileState(a).chunking.inProgress.splice(l,1),e._getFileState(a).chunking.remaining.unshift(f))),e._getFileState(a).temp.ignoreFailure||(h&&(e._getFileState(a).temp.ignoreFailure=!0,qq.each(e._getXhrs(a),function(a,b){b.abort()}),e.moveInProgressToRemaining(a),k.free(a,!0)),i.onAutoRetry(a,c,n,g)||m.cleanup(a,n,g))}).done(function(){e.clearXhr(a,f)}))}},k={_open:[],_openChunks:{},_waiting:[],available:function(){var a=i.maxConnections,b=0,c=0;return qq.each(k._openChunks,function(a,d){b++,c+=d.length}),a-(k._open.length-b+c)},free:function(a,b){var c,f=!b,g=qq.indexOf(k._waiting,a),h=qq.indexOf(k._open,a);delete k._openChunks[a],m.getProxyOrBlob(a)instanceof qq.BlobProxy&&(d("Generated blob upload has ended for "+a+", disposing generated blob."),delete e._getFileState(a).file),g>=0?k._waiting.splice(g,1):f&&h>=0&&(k._open.splice(h,1),c=k._waiting.shift(),c>=0&&(k._open.push(c),m.start(c)))},getWaitingOrConnected:function(){var a=[];return qq.each(k._openChunks,function(b,c){c&&c.length&&a.push(parseInt(b))}),qq.each(k._open,function(b,c){k._openChunks[c]||a.push(parseInt(c))}),a=a.concat(k._waiting)},isUsingConnection:function(a){return qq.indexOf(k._open,a)>=0},open:function(a,b){return null==b&&k._waiting.push(a),k.available()?(null==b?(k._waiting.pop(),k._open.push(a)):function(){var c=k._openChunks[a]||[];c.push(b),k._openChunks[a]=c}(),!0):!1},reset:function(){k._waiting=[],k._open=[]}},l={send:function(a,b){e._getFileState(a).loaded=0,d("Sending simple upload request for "+a),e.uploadFile(a).then(function(c,e){d("Simple upload request succeeded for "+a);var f=m.normalizeResponse(c,!0),g=i.getSize(a);i.onProgress(a,b,g,g),m.maybeNewUuid(a,f),m.cleanup(a,f,e)},function(c,e){d("Simple upload request failed for "+a);var f=m.normalizeResponse(c,!1);i.onAutoRetry(a,b,f,e)||m.cleanup(a,f,e)})}},m={cancel:function(a){d("Cancelling "+a),i.paramsStore.remove(a),k.free(a)},cleanup:function(a,b,c){var d=i.getName(a);i.onComplete(a,d,b,c),e._getFileState(a)&&e._clearXhrs&&e._clearXhrs(a),k.free(a)},getProxyOrBlob:function(a){return e.getProxy&&e.getProxy(a)||e.getFile&&e.getFile(a)},initHandler:function(){var a=b?qq[b]:qq.traditional,c=qq.supportedFeatures.ajaxUploading?"Xhr":"Form";e=new a[c+"UploadHandler"](i,{getDataByUuid:i.getDataByUuid,getName:i.getName,getSize:i.getSize,getUuid:i.getUuid,log:d,onCancel:i.onCancel,onProgress:i.onProgress,onUuidChanged:i.onUuidChanged}),e._removeExpiredChunkingRecords&&e._removeExpiredChunkingRecords()},isDeferredEligibleForUpload:function(a){return i.isQueued(a)},maybeDefer:function(a,b){return b&&!e.getFile(a)&&b instanceof qq.BlobProxy?(i.onUploadPrep(a),d("Attempting to generate a blob on-demand for "+a),b.create().then(function(b){d("Generated an on-demand blob for "+a),e.updateBlob(a,b),i.setSize(a,b.size),e.reevaluateChunking(a),m.maybeSendDeferredFiles(a)},function(b){var e={};b&&(e.error=b),d(qq.format("Failed to generate blob for ID {}.  Error message: {}.",a,b),"error"),i.onComplete(a,i.getName(a),qq.extend(e,c),null),m.maybeSendDeferredFiles(a),k.free(a)}),!1):m.maybeSendDeferredFiles(a)},maybeSendDeferredFiles:function(a){var b=i.getIdsInProxyGroup(a),c=!1;return b&&b.length?(d("Maybe ready to upload proxy group file "+a),qq.each(b,function(b,d){if(m.isDeferredEligibleForUpload(d)&&e.getFile(d))c=d===a,m.now(d);else if(m.isDeferredEligibleForUpload(d))return!1})):(c=!0,m.now(a)),c},maybeNewUuid:function(a,b){void 0!==b.newUuid&&i.onUuidChanged(a,b.newUuid)},normalizeResponse:function(a,b){var c=a;return qq.isObject(a)||(c={},qq.isString(a)&&!b&&(c.error=a)),c.success=b,c},now:function(a){var b=i.getName(a);if(!f.isValid(a))throw new qq.Error(a+" is not a valid file ID to upload!");i.onUpload(a,b),g&&e._shouldChunkThisFile(a)?j.sendNext(a):l.send(a,b)},start:function(a){var b=m.getProxyOrBlob(a);return b?m.maybeDefer(a,b):(m.now(a),!0)}};qq.extend(this,{add:function(){e.add.apply(this,arguments)},upload:function(a){return k.open(a)?m.start(a):!1},retry:function(a){return h&&(e._getFileState(a).temp.ignoreFailure=!1),k.isUsingConnection(a)?m.start(a):f.upload(a)},cancel:function(a){var b=e.cancel(a);qq.isGenericPromise(b)?b.then(function(){m.cancel(a)}):b!==!1&&m.cancel(a)},cancelAll:function(){var a,b=k.getWaitingOrConnected();if(b.length)for(a=b.length-1;a>=0;a--)f.cancel(b[a]);k.reset()},getFile:function(a){return e.getProxy&&e.getProxy(a)?e.getProxy(a).referenceBlob:e.getFile&&e.getFile(a)},isProxied:function(a){return!(!e.getProxy||!e.getProxy(a))},getInput:function(a){return e.getInput?e.getInput(a):void 0},reset:function(){d("Resetting upload handler"),f.cancelAll(),k.reset(),e.reset()},expunge:function(a){return f.isValid(a)?e.expunge(a):void 0},isValid:function(a){return e.isValid(a)},getResumableFilesData:function(){return e.getResumableFilesData?e.getResumableFilesData():[]},getThirdPartyFileId:function(a){return f.isValid(a)?e.getThirdPartyFileId(a):void 0},pause:function(a){return f.isResumable(a)&&e.pause&&f.isValid(a)&&e.pause(a)?(k.free(a),e.moveInProgressToRemaining(a),!0):!1},isResumable:function(a){return!!e.isResumable&&e.isResumable(a)}}),qq.extend(i,a),d=i.log,g=i.chunking.enabled&&qq.supportedFeatures.chunking,h=g&&i.chunking.concurrent.enabled,c=function(){var a={};return a[i.preventRetryParam]=!0,a}(),m.initHandler()},qq.FormUploadHandler=function(a){"use strict";function b(a){delete k[a],m&&(clearTimeout(l[a]),delete l[a],q.stopReceivingMessages(a));var b=document.getElementById(g._getIframeName(a));b&&(b.setAttribute("src","javascript:false;"),qq(b).remove())}function c(a){return a.split("_")[0]}function d(a){var b=qq.toElement("<iframe src='javascript:false;' name='"+a+"' />");return b.setAttribute("id",a),b.style.display="none",document.body.appendChild(b),b}function e(a,b){var d=a.id,e=c(d),f=o(e);j[f]=b,k[e]=qq(a).attach("load",function(){g.getInput(e)&&(p("Received iframe load event for CORS upload request (iframe name "+d+")"),l[d]=setTimeout(function(){var a="No valid message received from loaded iframe for iframe name "+d;p(a,"error"),b({error:a})},1e3))}),q.receiveMessage(d,function(a){p("Received the following window message: '"+a+"'");var b,e=(c(d),g._parseJsonResponse(a)),f=e.uuid;f&&j[f]?(p("Handling response for iframe name "+d),clearTimeout(l[d]),delete l[d],g._detachLoadEvent(d),b=j[f],delete j[f],q.stopReceivingMessages(d),b(e)):f||p("'"+a+"' does not contain a UUID - ignoring.")})}var f=a.options,g=this,h=a.proxy,i=qq.getUniqueId(),j={},k={},l={},m=f.isCors,n=f.inputName,o=h.getUuid,p=h.log,q=new qq.WindowReceiveMessage({log:p});qq.extend(this,new qq.UploadHandler(a)),qq.override(this,function(a){return{add:function(b,c){a.add(b,{input:c}),c.setAttribute("name",n),c.parentNode&&qq(c).remove()},expunge:function(c){b(c),a.expunge(c)},isValid:function(b){return a.isValid(b)&&void 0!==g._getFileState(b).input}}}),qq.extend(this,{getInput:function(a){return g._getFileState(a).input},_attachLoadEvent:function(a,b){var c;m?e(a,b):k[a.id]=qq(a).attach("load",function(){if(p("Received response for "+a.id),a.parentNode){try{if(a.contentDocument&&a.contentDocument.body&&"false"==a.contentDocument.body.innerHTML)return}catch(d){p("Error when attempting to access iframe during handling of upload response ("+d.message+")","error"),c={success:!1}}b(c)}})},_createIframe:function(a){var b=g._getIframeName(a);return d(b)},_detachLoadEvent:function(a){void 0!==k[a]&&(k[a](),delete k[a])},_getIframeName:function(a){return a+"_"+i},_initFormForUpload:function(a){var b=a.method,c=a.endpoint,d=a.params,e=a.paramsInBody,f=a.targetName,g=qq.toElement("<form method='"+b+"' enctype='multipart/form-data'></form>"),h=c;return e?qq.obj2Inputs(d,g):h=qq.obj2url(d,c),g.setAttribute("action",h),g.setAttribute("target",f),g.style.display="none",document.body.appendChild(g),g
+},_parseJsonResponse:function(a){var b={};try{b=qq.parseJson(a)}catch(c){p("Error when attempting to parse iframe upload response ("+c.message+")","error")}return b}})},qq.XhrUploadHandler=function(a){"use strict";function b(a){qq.each(c._getXhrs(a),function(b,d){var e=c._getAjaxRequester(a,b);d.onreadystatechange=null,d.upload.onprogress=null,d.abort(),e&&e.canceled&&e.canceled(a)})}var c=this,d=a.options.namespace,e=a.proxy,f=a.options.chunking,g=a.options.resume,h=f&&a.options.chunking.enabled&&qq.supportedFeatures.chunking,i=g&&a.options.resume.enabled&&h&&qq.supportedFeatures.resume,j=e.getName,k=e.getSize,l=e.getUuid,m=e.getEndpoint,n=e.getDataByUuid,o=e.onUuidChanged,p=e.onProgress,q=e.log;qq.extend(this,new qq.UploadHandler(a)),qq.override(this,function(a){return{add:function(b,d){if(qq.isFile(d)||qq.isBlob(d))a.add(b,{file:d});else{if(!(d instanceof qq.BlobProxy))throw new Error("Passed obj is not a File, Blob, or proxy");a.add(b,{proxy:d})}c._initTempState(b),i&&c._maybePrepareForResume(b)},expunge:function(d){b(d),c._maybeDeletePersistedChunkData(d),c._clearXhrs(d),a.expunge(d)}}}),qq.extend(this,{clearCachedChunk:function(a,b){delete c._getFileState(a).temp.cachedChunks[b]},clearXhr:function(a,b){var d=c._getFileState(a).temp;d.xhrs&&delete d.xhrs[b],d.ajaxRequesters&&delete d.ajaxRequesters[b]},finalizeChunks:function(a,b){var d=c._getTotalChunks(a)-1,e=c._getXhr(a,d);return b?(new qq.Promise).success(b(e),e):(new qq.Promise).success({},e)},getFile:function(a){return c.isValid(a)&&c._getFileState(a).file},getProxy:function(a){return c.isValid(a)&&c._getFileState(a).proxy},getResumableFilesData:function(){var a=[];return c._iterateResumeRecords(function(b,d){c.moveInProgressToRemaining(null,d.chunking.inProgress,d.chunking.remaining);var e={name:d.name,remaining:d.chunking.remaining,size:d.size,uuid:d.uuid};d.key&&(e.key=d.key),a.push(e)}),a},isResumable:function(a){return!!f&&c.isValid(a)&&!c._getFileState(a).notResumable},moveInProgressToRemaining:function(a,b,d){var e=b||c._getFileState(a).chunking.inProgress,f=d||c._getFileState(a).chunking.remaining;e&&(e.reverse(),qq.each(e,function(a,b){f.unshift(b)}),e.length=0)},pause:function(a){return c.isValid(a)?(q(qq.format("Aborting XHR upload for {} '{}' due to pause instruction.",a,j(a))),c._getFileState(a).paused=!0,b(a),!0):void 0},reevaluateChunking:function(a){if(f&&c.isValid(a)){var b,d,e=c._getFileState(a);if(delete e.chunking,e.chunking={},b=c._getTotalChunks(a),b>1||f.mandatory){for(e.chunking.enabled=!0,e.chunking.parts=b,e.chunking.remaining=[],d=0;b>d;d++)e.chunking.remaining.push(d);c._initTempState(a)}else e.chunking.enabled=!1}},updateBlob:function(a,b){c.isValid(a)&&(c._getFileState(a).file=b)},_clearXhrs:function(a){var b=c._getFileState(a).temp;qq.each(b.ajaxRequesters,function(a){delete b.ajaxRequesters[a]}),qq.each(b.xhrs,function(a){delete b.xhrs[a]})},_createXhr:function(a,b){return c._registerXhr(a,b,qq.createXhrInstance())},_getAjaxRequester:function(a,b){var d=null==b?-1:b;return c._getFileState(a).temp.ajaxRequesters[d]},_getChunkData:function(a,b){var d=f.partSize,e=k(a),g=c.getFile(a),h=d*b,i=h+d>=e?e:h+d,j=c._getTotalChunks(a),l=this._getFileState(a).temp.cachedChunks,m=l[b]||qq.sliceBlob(g,h,i);return l[b]=m,{part:b,start:h,end:i,count:j,blob:m,size:i-h}},_getChunkDataForCallback:function(a){return{partIndex:a.part,startByte:a.start+1,endByte:a.end,totalParts:a.count}},_getLocalStorageId:function(a){var b="5.0",c=j(a),e=k(a),g=f.partSize,h=m(a);return qq.format("qq{}resume{}-{}-{}-{}-{}",d,b,c,e,g,h)},_getMimeType:function(a){return c.getFile(a).type},_getPersistableData:function(a){return c._getFileState(a).chunking},_getTotalChunks:function(a){if(f){var b=k(a),c=f.partSize;return Math.ceil(b/c)}},_getXhr:function(a,b){var d=null==b?-1:b;return c._getFileState(a).temp.xhrs[d]},_getXhrs:function(a){return c._getFileState(a).temp.xhrs},_iterateResumeRecords:function(a){i&&qq.each(localStorage,function(b,c){if(0===b.indexOf(qq.format("qq{}resume-",d))){var e=JSON.parse(c);a(b,e)}})},_initTempState:function(a){c._getFileState(a).temp={ajaxRequesters:{},chunkProgress:{},xhrs:{},cachedChunks:{}}},_markNotResumable:function(a){c._getFileState(a).notResumable=!0},_maybeDeletePersistedChunkData:function(a){var b;return i&&c.isResumable(a)&&(b=c._getLocalStorageId(a),b&&localStorage.getItem(b))?(localStorage.removeItem(b),!0):!1},_maybePrepareForResume:function(a){var b,d,e=c._getFileState(a);i&&void 0===e.key&&(b=c._getLocalStorageId(a),d=localStorage.getItem(b),d&&(d=JSON.parse(d),n(d.uuid)?c._markNotResumable(a):(q(qq.format("Identified file with ID {} and name of {} as resumable.",a,j(a))),o(a,d.uuid),e.key=d.key,e.chunking=d.chunking,e.loaded=d.loaded,e.attemptingResume=!0,c.moveInProgressToRemaining(a))))},_maybePersistChunkedState:function(a){var b,d,e=c._getFileState(a);if(i&&c.isResumable(a)){b=c._getLocalStorageId(a),d={name:j(a),size:k(a),uuid:l(a),key:e.key,chunking:e.chunking,loaded:e.loaded,lastUpdated:Date.now()};try{localStorage.setItem(b,JSON.stringify(d))}catch(f){q(qq.format("Unable to save resume data for '{}' due to error: '{}'.",a,f.toString()),"warn")}}},_registerProgressHandler:function(a,b,d){var e=c._getXhr(a,b),f=j(a),g={simple:function(b,c){var d=k(a);b===c?p(a,f,d,d):p(a,f,b>=d?d-1:b,d)},chunked:function(e,g){var h=c._getFileState(a).temp.chunkProgress,i=c._getFileState(a).loaded,j=e,l=g,m=k(a),n=j-(l-d),o=i;h[b]=n,qq.each(h,function(a,b){o+=b}),p(a,f,o,m)}};e.upload.onprogress=function(a){if(a.lengthComputable){var b=null==d?"simple":"chunked";g[b](a.loaded,a.total)}}},_registerXhr:function(a,b,d,e){var f=null==b?-1:b,g=c._getFileState(a).temp;return g.xhrs=g.xhrs||{},g.ajaxRequesters=g.ajaxRequesters||{},g.xhrs[f]=d,e&&(g.ajaxRequesters[f]=e),d},_removeExpiredChunkingRecords:function(){var a=g.recordsExpireIn;c._iterateResumeRecords(function(b,c){var d=new Date(c.lastUpdated);d.setDate(d.getDate()+a),d.getTime()<=Date.now()&&(q("Removing expired resume record with key "+b),localStorage.removeItem(b))})},_shouldChunkThisFile:function(a){var b=c._getFileState(a);return b.chunking||c.reevaluateChunking(a),b.chunking.enabled}})},qq.WindowReceiveMessage=function(a){"use strict";var b={log:function(){}},c={};qq.extend(b,a),qq.extend(this,{receiveMessage:function(a,b){var d=function(a){b(a.data)};window.postMessage?c[a]=qq(window).attach("message",d):log("iframe message passing not supported in this browser!","error")},stopReceivingMessages:function(a){if(window.postMessage){var b=c[a];b&&b()}}})},function(){"use strict";qq.uiPublicApi={clearStoredFiles:function(){this._parent.prototype.clearStoredFiles.apply(this,arguments),this._templating.clearFiles()},addExtraDropzone:function(a){this._dnd&&this._dnd.setupExtraDropzone(a)},removeExtraDropzone:function(a){return this._dnd?this._dnd.removeDropzone(a):void 0},getItemByFileId:function(a){return this._templating.getFileContainer(a)},reset:function(){this._parent.prototype.reset.apply(this,arguments),this._templating.reset(),!this._options.button&&this._templating.getButton()&&(this._defaultButtonId=this._createUploadButton({element:this._templating.getButton()}).getButtonId()),this._dnd&&(this._dnd.dispose(),this._dnd=this._setupDragAndDrop()),this._totalFilesInBatch=0,this._filesInBatchAddedToUi=0,this._setupClickAndEditEventHandlers()},setName:function(a,b){var c=this._options.formatFileName(b);this._parent.prototype.setName.apply(this,arguments),this._templating.updateFilename(a,c)},pauseUpload:function(a){var b=this._parent.prototype.pauseUpload.apply(this,arguments);return b&&this._templating.uploadPaused(a),b},continueUpload:function(a){var b=this._parent.prototype.continueUpload.apply(this,arguments);return b&&this._templating.uploadContinued(a),b},getId:function(a){return this._templating.getFileId(a)},getDropTarget:function(a){var b=this.getFile(a);return b.qqDropTarget}},qq.uiPrivateApi={_getButton:function(a){var b=this._parent.prototype._getButton.apply(this,arguments);return b||a===this._defaultButtonId&&(b=this._templating.getButton()),b},_removeFileItem:function(a){this._templating.removeFile(a)},_setupClickAndEditEventHandlers:function(){this._fileButtonsClickHandler=qq.FileButtonsClickHandler&&this._bindFileButtonsClickEvent(),this._focusinEventSupported=!qq.firefox(),this._isEditFilenameEnabled()&&(this._filenameClickHandler=this._bindFilenameClickEvent(),this._filenameInputFocusInHandler=this._bindFilenameInputFocusInEvent(),this._filenameInputFocusHandler=this._bindFilenameInputFocusEvent())},_setupDragAndDrop:function(){var a=this,b=this._options.dragAndDrop.extraDropzones,c=this._templating,d=c.getDropZone();return d&&b.push(d),new qq.DragAndDrop({dropZoneElements:b,allowMultipleItems:this._options.multiple,classes:{dropActive:this._options.classes.dropActive},callbacks:{processingDroppedFiles:function(){c.showDropProcessing()},processingDroppedFilesComplete:function(b,d){c.hideDropProcessing(),qq.each(b,function(a,b){b.qqDropTarget=d}),b.length&&a.addFiles(b,null,null)},dropError:function(b,c){a._itemError(b,c)},dropLog:function(b,c){a.log(b,c)}}})},_bindFileButtonsClickEvent:function(){var a=this;return new qq.FileButtonsClickHandler({templating:this._templating,log:function(b,c){a.log(b,c)},onDeleteFile:function(b){a.deleteFile(b)},onCancel:function(b){a.cancel(b)},onRetry:function(b){qq(a._templating.getFileContainer(b)).removeClass(a._classes.retryable),a._templating.hideRetry(b),a.retry(b)},onPause:function(b){a.pauseUpload(b)},onContinue:function(b){a.continueUpload(b)},onGetName:function(b){return a.getName(b)}})},_isEditFilenameEnabled:function(){return this._templating.isEditFilenamePossible()&&!this._options.autoUpload&&qq.FilenameClickHandler&&qq.FilenameInputFocusHandler&&qq.FilenameInputFocusHandler},_filenameEditHandler:function(){var a=this,b=this._templating;return{templating:b,log:function(b,c){a.log(b,c)},onGetUploadStatus:function(b){return a.getUploads({id:b}).status},onGetName:function(b){return a.getName(b)},onSetName:function(b,c){a.setName(b,c)},onEditingStatusChange:function(a,c){var d=qq(b.getEditInput(a)),e=qq(b.getFileContainer(a));c?(d.addClass("qq-editing"),b.hideFilename(a),b.hideEditIcon(a)):(d.removeClass("qq-editing"),b.showFilename(a),b.showEditIcon(a)),e.addClass("qq-temp").removeClass("qq-temp")}}},_onUploadStatusChange:function(a,b,c){this._parent.prototype._onUploadStatusChange.apply(this,arguments),this._isEditFilenameEnabled()&&this._templating.getFileContainer(a)&&c!==qq.status.SUBMITTED&&(this._templating.markFilenameEditable(a),this._templating.hideEditIcon(a)),c===qq.status.UPLOAD_RETRYING?(this._templating.setStatusText(a),qq(this._templating.getFileContainer(a)).removeClass(this._classes.retrying)):c===qq.status.UPLOAD_FAILED&&this._templating.hidePause(a)},_bindFilenameInputFocusInEvent:function(){var a=qq.extend({},this._filenameEditHandler());return new qq.FilenameInputFocusInHandler(a)},_bindFilenameInputFocusEvent:function(){var a=qq.extend({},this._filenameEditHandler());return new qq.FilenameInputFocusHandler(a)},_bindFilenameClickEvent:function(){var a=qq.extend({},this._filenameEditHandler());return new qq.FilenameClickHandler(a)},_storeForLater:function(a){this._parent.prototype._storeForLater.apply(this,arguments),this._templating.hideSpinner(a)},_onAllComplete:function(){this._parent.prototype._onAllComplete.apply(this,arguments),this._templating.resetTotalProgress()},_onSubmit:function(a,b){var c=this.getFile(a);c&&c.qqPath&&this._options.dragAndDrop.reportDirectoryPaths&&this._paramsStore.addReadOnly(a,{qqpath:c.qqPath}),this._parent.prototype._onSubmit.apply(this,arguments),this._addToList(a,b)},_onSubmitted:function(a){this._isEditFilenameEnabled()&&(this._templating.markFilenameEditable(a),this._templating.showEditIcon(a),this._focusinEventSupported||this._filenameInputFocusHandler.addHandler(this._templating.getEditInput(a)))},_onProgress:function(a,b,c,d){this._parent.prototype._onProgress.apply(this,arguments),this._templating.updateProgress(a,c,d),100===Math.round(100*(c/d))?(this._templating.hideCancel(a),this._templating.hidePause(a),this._templating.hideProgress(a),this._templating.setStatusText(a,this._options.text.waitingForResponse),this._displayFileSize(a)):this._displayFileSize(a,c,d)},_onTotalProgress:function(a,b){this._parent.prototype._onTotalProgress.apply(this,arguments),this._templating.updateTotalProgress(a,b)},_onComplete:function(a,b,c){function d(b){g&&(f.setStatusText(a),qq(g).removeClass(h._classes.retrying),f.hideProgress(a),h.getUploads({id:a}).status!==qq.status.UPLOAD_FAILED&&f.hideCancel(a),f.hideSpinner(a),b.success?h._markFileAsSuccessful(a):(qq(g).addClass(h._classes.fail),f.showCancel(a),f.isRetryPossible()&&!h._preventRetries[a]&&(qq(g).addClass(h._classes.retryable),f.showRetry(a)),h._controlFailureTextDisplay(a,b)))}var e=this._parent.prototype._onComplete.apply(this,arguments),f=this._templating,g=f.getFileContainer(a),h=this;return e instanceof qq.Promise?e.done(function(a){d(a)}):d(c),e},_markFileAsSuccessful:function(a){var b=this._templating;this._isDeletePossible()&&b.showDeleteButton(a),qq(b.getFileContainer(a)).addClass(this._classes.success),this._maybeUpdateThumbnail(a)},_onUploadPrep:function(a){this._parent.prototype._onUploadPrep.apply(this,arguments),this._templating.showSpinner(a)},_onUpload:function(a){var b=this._parent.prototype._onUpload.apply(this,arguments);return this._templating.showSpinner(a),b},_onUploadChunk:function(a,b){this._parent.prototype._onUploadChunk.apply(this,arguments),b.partIndex>0&&this._handler.isResumable(a)&&this._templating.allowPause(a)},_onCancel:function(a){this._parent.prototype._onCancel.apply(this,arguments),this._removeFileItem(a),0===this._getNotFinished()&&this._templating.resetTotalProgress()},_onBeforeAutoRetry:function(a){var b,c,d;this._parent.prototype._onBeforeAutoRetry.apply(this,arguments),this._showCancelLink(a),this._options.retry.showAutoRetryNote&&(b=this._autoRetries[a],c=this._options.retry.maxAutoAttempts,d=this._options.retry.autoRetryNote.replace(/\{retryNum\}/g,b),d=d.replace(/\{maxAuto\}/g,c),this._templating.setStatusText(a,d),qq(this._templating.getFileContainer(a)).addClass(this._classes.retrying))},_onBeforeManualRetry:function(a){return this._parent.prototype._onBeforeManualRetry.apply(this,arguments)?(this._templating.resetProgress(a),qq(this._templating.getFileContainer(a)).removeClass(this._classes.fail),this._templating.setStatusText(a),this._templating.showSpinner(a),this._showCancelLink(a),!0):(qq(this._templating.getFileContainer(a)).addClass(this._classes.retryable),this._templating.showRetry(a),!1)},_onSubmitDelete:function(a){var b=qq.bind(this._onSubmitDeleteSuccess,this);this._parent.prototype._onSubmitDelete.call(this,a,b)},_onSubmitDeleteSuccess:function(){this._options.deleteFile.forceConfirm?this._showDeleteConfirm.apply(this,arguments):this._sendDeleteRequest.apply(this,arguments)},_onDeleteComplete:function(a,b,c){this._parent.prototype._onDeleteComplete.apply(this,arguments),this._templating.hideSpinner(a),c?(this._templating.setStatusText(a,this._options.deleteFile.deletingFailedText),this._templating.showDeleteButton(a)):this._removeFileItem(a)},_sendDeleteRequest:function(a){this._templating.hideDeleteButton(a),this._templating.showSpinner(a),this._templating.setStatusText(a,this._options.deleteFile.deletingStatusText),this._deleteHandler.sendDelete.apply(this,arguments)},_showDeleteConfirm:function(a){var b,c=this.getName(a),d=this._options.deleteFile.confirmMessage.replace(/\{filename\}/g,c),e=(this.getUuid(a),arguments),f=this;b=this._options.showConfirm(d),qq.isGenericPromise(b)?b.then(function(){f._sendDeleteRequest.apply(f,e)}):b!==!1&&f._sendDeleteRequest.apply(f,e)},_addToList:function(a,b,c){var d,e,f=0,g=this._handler.isProxied(a)&&this._options.scaling.hideScaled;g||(this._options.display.prependFiles&&(this._totalFilesInBatch>1&&this._filesInBatchAddedToUi>0&&(f=this._filesInBatchAddedToUi-1),d={index:f}),c||(this._options.disableCancelForFormUploads&&!qq.supportedFeatures.ajaxUploading&&this._templating.disableCancel(),this._options.multiple||(e=this.getUploads({id:a}),this._handledProxyGroup=this._handledProxyGroup||e.proxyGroupId,e.proxyGroupId===this._handledProxyGroup&&e.proxyGroupId||(this._handler.cancelAll(),this._clearList(),this._handledProxyGroup=null))),this._templating.addFile(a,this._options.formatFileName(b),d),c?this._thumbnailUrls[a]&&this._templating.updateThumbnail(a,this._thumbnailUrls[a],!0):this._templating.generatePreview(a,this.getFile(a)),this._filesInBatchAddedToUi+=1,(c||this._options.display.fileSizeOnSubmit&&qq.supportedFeatures.ajaxUploading)&&this._displayFileSize(a))},_clearList:function(){this._templating.clearFiles(),this.clearStoredFiles()},_displayFileSize:function(a,b,c){var d=this.getSize(a),e=this._formatSize(d);d>=0&&(void 0!==b&&void 0!==c&&(e=this._formatProgress(b,c)),this._templating.updateSize(a,e))},_formatProgress:function(a,b){function c(a,b){d=d.replace(a,b)}var d=this._options.text.formatProgress;return c("{percent}",Math.round(100*(a/b))),c("{total_size}",this._formatSize(b)),d},_controlFailureTextDisplay:function(a,b){var c,d,e;c=this._options.failedUploadTextDisplay.mode,d=this._options.failedUploadTextDisplay.responseProperty,"custom"===c?(e=b[d],e||(e=this._options.text.failUpload),this._templating.setStatusText(a,e),this._options.failedUploadTextDisplay.enableTooltip&&this._showTooltip(a,e)):"default"===c?this._templating.setStatusText(a,this._options.text.failUpload):"none"!==c&&this.log("failedUploadTextDisplay.mode value of '"+c+"' is not valid","warn")},_showTooltip:function(a,b){this._templating.getFileContainer(a).title=b},_showCancelLink:function(a){(!this._options.disableCancelForFormUploads||qq.supportedFeatures.ajaxUploading)&&this._templating.showCancel(a)},_itemError:function(){var a=this._parent.prototype._itemError.apply(this,arguments);this._options.showMessage(a)},_batchError:function(a){this._parent.prototype._batchError.apply(this,arguments),this._options.showMessage(a)},_setupPastePrompt:function(){var a=this;this._options.callbacks.onPasteReceived=function(){var b=a._options.paste.namePromptMessage,c=a._options.paste.defaultName;return a._options.showPrompt(b,c)}},_fileOrBlobRejected:function(){this._totalFilesInBatch-=1,this._parent.prototype._fileOrBlobRejected.apply(this,arguments)},_prepareItemsForUpload:function(a){this._totalFilesInBatch=a.length,this._filesInBatchAddedToUi=0,this._parent.prototype._prepareItemsForUpload.apply(this,arguments)},_maybeUpdateThumbnail:function(a){var b=this._thumbnailUrls[a],c=this.getUploads({id:a}).status;c===qq.status.DELETED||!b&&!this._options.thumbnails.placeholders.waitUntilResponse&&qq.supportedFeatures.imagePreviews||this._templating.updateThumbnail(a,b)},_addCannedFile:function(){var a=this._parent.prototype._addCannedFile.apply(this,arguments);return this._addToList(a,this.getName(a),!0),this._templating.hideSpinner(a),this._templating.hideCancel(a),this._markFileAsSuccessful(a),a},_setSize:function(a,b){this._parent.prototype._setSize.apply(this,arguments),this._templating.updateSize(a,this._formatSize(b))}}}(),qq.FineUploader=function(a,b){"use strict";var c=this;this._parent=b?qq[b].FineUploaderBasic:qq.FineUploaderBasic,this._parent.apply(this,arguments),qq.extend(this._options,{element:null,button:null,listElement:null,dragAndDrop:{extraDropzones:[],reportDirectoryPaths:!1},text:{formatProgress:"{percent}% of {total_size}",failUpload:"Upload failed",waitingForResponse:"Processing...",paused:"Paused"},template:"qq-template",classes:{retrying:"qq-upload-retrying",retryable:"qq-upload-retryable",success:"qq-upload-success",fail:"qq-upload-fail",editable:"qq-editable",hide:"qq-hide",dropActive:"qq-upload-drop-area-active"},failedUploadTextDisplay:{mode:"default",responseProperty:"error",enableTooltip:!0},messages:{tooManyFilesError:"You may only drop one file",unsupportedBrowser:"Unrecoverable error - this browser does not permit file uploading of any kind."},retry:{showAutoRetryNote:!0,autoRetryNote:"Retrying {retryNum}/{maxAuto}..."},deleteFile:{forceConfirm:!1,confirmMessage:"Are you sure you want to delete {filename}?",deletingStatusText:"Deleting...",deletingFailedText:"Delete failed"},display:{fileSizeOnSubmit:!1,prependFiles:!1},paste:{promptForName:!1,namePromptMessage:"Please name this image"},thumbnails:{maxCount:0,placeholders:{waitUntilResponse:!1,notAvailablePath:null,waitingPath:null},timeBetweenThumbs:750},scaling:{hideScaled:!1},showMessage:function(a){return c._templating.hasDialog("alert")?c._templating.showDialog("alert",a):(setTimeout(function(){window.alert(a)},0),void 0)},showConfirm:function(a){return c._templating.hasDialog("confirm")?c._templating.showDialog("confirm",a):window.confirm(a)},showPrompt:function(a,b){return c._templating.hasDialog("prompt")?c._templating.showDialog("prompt",a,b):window.prompt(a,b)}},!0),qq.extend(this._options,a,!0),this._templating=new qq.Templating({log:qq.bind(this.log,this),templateIdOrEl:this._options.template,containerEl:this._options.element,fileContainerEl:this._options.listElement,button:this._options.button,imageGenerator:this._imageGenerator,classes:{hide:this._options.classes.hide,editable:this._options.classes.editable},limits:{maxThumbs:this._options.thumbnails.maxCount,timeBetweenThumbs:this._options.thumbnails.timeBetweenThumbs},placeholders:{waitUntilUpdate:this._options.thumbnails.placeholders.waitUntilResponse,thumbnailNotAvailable:this._options.thumbnails.placeholders.notAvailablePath,waitingForThumbnail:this._options.thumbnails.placeholders.waitingPath},text:this._options.text}),this._options.workarounds.ios8SafariUploads&&qq.ios800()&&qq.iosSafari()?this._templating.renderFailure(this._options.messages.unsupportedBrowserIos8Safari):!qq.supportedFeatures.uploading||this._options.cors.expected&&!qq.supportedFeatures.uploadCors?this._templating.renderFailure(this._options.messages.unsupportedBrowser):(this._wrapCallbacks(),this._templating.render(),this._classes=this._options.classes,!this._options.button&&this._templating.getButton()&&(this._defaultButtonId=this._createUploadButton({element:this._templating.getButton()}).getButtonId()),this._setupClickAndEditEventHandlers(),qq.DragAndDrop&&qq.supportedFeatures.fileDrop&&(this._dnd=this._setupDragAndDrop()),this._options.paste.targetElement&&this._options.paste.promptForName&&(qq.PasteSupport?this._setupPastePrompt():this.log("Paste support module not found.","error")),this._totalFilesInBatch=0,this._filesInBatchAddedToUi=0)},qq.extend(qq.FineUploader.prototype,qq.basePublicApi),qq.extend(qq.FineUploader.prototype,qq.basePrivateApi),qq.extend(qq.FineUploader.prototype,qq.uiPublicApi),qq.extend(qq.FineUploader.prototype,qq.uiPrivateApi),qq.Templating=function(a){"use strict";var b,c,d,e,f,g,h,i,j="qq-file-id",k="qq-file-id-",l="qq-max-size",m="qq-server-scale",n="qq-hide-dropzone",o="qq-drop-area-text",p="qq-in-progress",q=!1,r=0,s=!1,t=[],u=-1,v={log:null,limits:{maxThumbs:0,timeBetweenThumbs:750},templateIdOrEl:"qq-template",containerEl:null,fileContainerEl:null,button:null,imageGenerator:null,classes:{hide:"qq-hide",editable:"qq-editable"},placeholders:{waitUntilUpdate:!1,thumbnailNotAvailable:null,waitingForThumbnail:null},text:{paused:"Paused"}},w={button:"qq-upload-button-selector",alertDialog:"qq-alert-dialog-selector",dialogCancelButton:"qq-cancel-button-selector",confirmDialog:"qq-confirm-dialog-selector",dialogMessage:"qq-dialog-message-selector",dialogOkButton:"qq-ok-button-selector",promptDialog:"qq-prompt-dialog-selector",uploader:"qq-uploader-selector",drop:"qq-upload-drop-area-selector",list:"qq-upload-list-selector",progressBarContainer:"qq-progress-bar-container-selector",progressBar:"qq-progress-bar-selector",totalProgressBarContainer:"qq-total-progress-bar-container-selector",totalProgressBar:"qq-total-progress-bar-selector",file:"qq-upload-file-selector",spinner:"qq-upload-spinner-selector",size:"qq-upload-size-selector",cancel:"qq-upload-cancel-selector",pause:"qq-upload-pause-selector",continueButton:"qq-upload-continue-selector",deleteButton:"qq-upload-delete-selector",retry:"qq-upload-retry-selector",statusText:"qq-upload-status-text-selector",editFilenameInput:"qq-edit-filename-selector",editNameIcon:"qq-edit-filename-icon-selector",dropText:"qq-upload-drop-area-text-selector",dropProcessing:"qq-drop-processing-selector",dropProcessingSpinner:"qq-drop-processing-spinner-selector",thumbnail:"qq-thumbnail-selector"},x={},y=new qq.Promise,z=new qq.Promise,A=function(){var a=v.placeholders.thumbnailNotAvailable,c=v.placeholders.waitingForThumbnail,d={maxSize:u,scale:i};h&&(a?v.imageGenerator.generate(a,new Image,d).then(function(a){y.success(a)},function(){y.failure(),b("Problem loading 'not available' placeholder image at "+a,"error")}):y.failure(),c?v.imageGenerator.generate(c,new Image,d).then(function(a){z.success(a)},function(){z.failure(),b("Problem loading 'waiting for thumbnail' placeholder image at "+c,"error")}):z.failure())},B=function(a){var b=new qq.Promise;return z.then(function(c){U(c,a),a.src?b.success():(a.src=c.src,a.onload=function(){a.onload=null,_(a),b.success()})},function(){T(a),b.success()}),b},C=function(a,c,d){var e=S(a);return b("Generating new thumbnail for "+a),c.qqThumbnailId=a,v.imageGenerator.generate(c,e,d).then(function(){r++,_(e),x[a].success()},function(){x[a].failure(),v.placeholders.waitUntilUpdate||V(a,e)})},D=function(){if(t.length){s=!0;var a=t.shift();a.update?Z(a):Y(a)}else s=!1},E=function(a){return R(K(a),w.cancel)},F=function(a){return R(K(a),w.continueButton)},G=function(a){return R(f,w[a+"Dialog"])},H=function(a){return R(K(a),w.deleteButton)},I=function(){return R(f,w.dropProcessing)},J=function(a){return R(K(a),w.editNameIcon)},K=function(a){return qq(g).getByClass(k+a)[0]},L=function(a){return R(K(a),w.file)},M=function(a){return R(K(a),w.pause)},N=function(a){return null==a?R(f,w.totalProgressBarContainer)||R(f,w.totalProgressBar):R(K(a),w.progressBarContainer)||R(K(a),w.progressBar)},O=function(a){return R(K(a),w.retry)},P=function(a){return R(K(a),w.size)},Q=function(a){return R(K(a),w.spinner)},R=function(a,b){return a&&qq(a).getByClass(b)[0]},S=function(a){return h&&R(K(a),w.thumbnail)},T=function(a){a&&qq(a).addClass(v.classes.hide)},U=function(a,b){var c=a.style.maxWidth,d=a.style.maxHeight;d&&c&&!b.style.maxWidth&&!b.style.maxHeight&&qq(b).css({maxWidth:c,maxHeight:d})},V=function(a,b){var c=x[a]||(new qq.Promise).failure(),d=new qq.Promise;return y.then(function(a){c.then(function(){d.success()},function(){U(a,b),b.onload=function(){b.onload=null,d.success()},b.src=a.src,_(b)})}),d},W=function(){var a,e,f,g,j,k,p,q,r,s,t;if(b("Parsing template"),null==v.templateIdOrEl)throw new Error("You MUST specify either a template element or ID!");if(qq.isString(v.templateIdOrEl)){if(a=document.getElementById(v.templateIdOrEl),null===a)throw new Error(qq.format("Cannot find template script at ID '{}'!",v.templateIdOrEl));e=a.innerHTML}else{if(void 0===v.templateIdOrEl.innerHTML)throw new Error("You have specified an invalid value for the template option!  It must be an ID or an Element.");e=v.templateIdOrEl.innerHTML}if(e=qq.trimStr(e),g=document.createElement("div"),g.appendChild(qq.toElement(e)),t=qq(g).getByClass(w.uploader)[0],v.button&&(k=qq(g).getByClass(w.button)[0],k&&qq(k).remove()),qq.DragAndDrop&&qq.supportedFeatures.fileDrop||(r=qq(g).getByClass(w.dropProcessing)[0],r&&qq(r).remove()),p=qq(g).getByClass(w.drop)[0],p&&!qq.DragAndDrop&&(b("DnD module unavailable.","info"),qq(p).remove()),qq.supportedFeatures.fileDrop?qq(t).hasAttribute(o)&&p&&(s=qq(p).getByClass(w.dropText)[0],s&&qq(s).remove()):(t.removeAttribute(o),p&&qq(p).hasAttribute(n)&&qq(p).css({display:"none"})),q=qq(g).getByClass(w.thumbnail)[0],h?q&&(u=parseInt(q.getAttribute(l)),u=u>0?u:null,i=qq(q).hasAttribute(m)):q&&qq(q).remove(),h=h&&q,c=qq(g).getByClass(w.editFilenameInput).length>0,d=qq(g).getByClass(w.retry).length>0,f=qq(g).getByClass(w.list)[0],null==f)throw new Error("Could not find the file list container in the template!");return j=f.innerHTML,f.innerHTML="",g.getElementsByTagName("DIALOG").length&&document.createElement("dialog"),b("Template parsing complete"),{template:qq.trimStr(g.innerHTML),fileTemplate:qq.trimStr(j)}},X=function(a,b){var c=g,d=c.firstChild;b>0&&(d=qq(c).children()[b].nextSibling),c.insertBefore(a,d)},Y=function(a){var b=a.id,c=a.optFileOrBlob,d=c&&c.qqThumbnailId,e=S(b),f={maxSize:u,scale:!0,orient:!0};qq.supportedFeatures.imagePreviews?e?v.limits.maxThumbs&&v.limits.maxThumbs<=r?(V(b,e),D()):B(e).done(function(){x[b]=new qq.Promise,x[b].done(function(){setTimeout(D,v.limits.timeBetweenThumbs)}),null!=d?ab(b,d):C(b,c,f)}):D():e&&(B(e),D())},Z=function(a){var b=a.id,c=a.thumbnailUrl,d=a.showWaitingImg,e=S(b),f={maxSize:u,scale:i};if(e)if(c){if(!(v.limits.maxThumbs&&v.limits.maxThumbs<=r))return d&&B(e),v.imageGenerator.generate(c,e,f).then(function(){_(e),r++,setTimeout(D,v.limits.timeBetweenThumbs)},function(){V(b,e),setTimeout(D,v.limits.timeBetweenThumbs)});V(b,e),D()}else V(b,e),D()},$=function(a,b){var c=N(a),d=null==a?w.totalProgressBar:w.progressBar;c&&!qq(c).hasClass(d)&&(c=qq(c).getByClass(d)[0]),c&&(qq(c).css({width:b+"%"}),c.setAttribute("aria-valuenow",b))},_=function(a){a&&qq(a).removeClass(v.classes.hide)},ab=function(a,c){var d=S(a),e=S(c);b(qq.format("ID {} is the same file as ID {}.  Will use generated thumbnail from ID {} instead.",a,c,c)),x[c].then(function(){r++,x[a].success(),b(qq.format("Now using previously generated thumbnail created for ID {} on ID {}.",c,a)),d.src=e.src,_(d)},function(){x[a].failure(),v.placeholders.waitUntilUpdate||V(a,d)})};qq.extend(v,a),b=v.log,qq.supportedFeatures.imagePreviews||(v.limits.timeBetweenThumbs=0,v.limits.maxThumbs=0),f=v.containerEl,h=void 0!==v.imageGenerator,e=W(),A(),qq.extend(this,{render:function(){b("Rendering template in DOM."),r=0,f.innerHTML=e.template,T(I()),this.hideTotalProgress(),g=v.fileContainerEl||R(f,w.list),b("Template rendering complete")},renderFailure:function(a){var b=qq.toElement(a);f.innerHTML="",f.appendChild(b)},reset:function(){this.render()},clearFiles:function(){g.innerHTML=""},disableCancel:function(){q=!0},addFile:function(a,b,c){var d,h=qq.toElement(e.fileTemplate),i=R(h,w.file),l=R(f,w.uploader);qq(h).addClass(k+a),l.removeAttribute(o),i&&(qq(i).setText(b),i.setAttribute("title",b)),h.setAttribute(j,a),c?X(h,c.index):g.appendChild(h),T(N(a)),T(P(a)),T(H(a)),T(O(a)),T(M(a)),T(F(a)),q&&this.hideCancel(a),d=S(a),d&&!d.src&&z.then(function(a){d.src=a.src,a.style.maxHeight&&a.style.maxWidth&&qq(d).css({maxHeight:a.style.maxHeight,maxWidth:a.style.maxWidth}),_(d)})},removeFile:function(a){qq(K(a)).remove()},getFileId:function(a){var b=a;if(b){for(;null==b.getAttribute(j);)b=b.parentNode;return parseInt(b.getAttribute(j))}},getFileList:function(){return g},markFilenameEditable:function(a){var b=L(a);b&&qq(b).addClass(v.classes.editable)},updateFilename:function(a,b){var c=L(a);c&&(qq(c).setText(b),c.setAttribute("title",b))},hideFilename:function(a){T(L(a))},showFilename:function(a){_(L(a))},isFileName:function(a){return qq(a).hasClass(w.file)},getButton:function(){return v.button||R(f,w.button)},hideDropProcessing:function(){T(I())},showDropProcessing:function(){_(I())},getDropZone:function(){return R(f,w.drop)},isEditFilenamePossible:function(){return c},hideRetry:function(a){T(O(a))},isRetryPossible:function(){return d},showRetry:function(a){_(O(a))},getFileContainer:function(a){return K(a)},showEditIcon:function(a){var b=J(a);b&&qq(b).addClass(v.classes.editable)},hideEditIcon:function(a){var b=J(a);b&&qq(b).removeClass(v.classes.editable)},isEditIcon:function(a){return qq(a).hasClass(w.editNameIcon,!0)},getEditInput:function(a){return R(K(a),w.editFilenameInput)},isEditInput:function(a){return qq(a).hasClass(w.editFilenameInput,!0)},updateProgress:function(a,b,c){var d,e=N(a);e&&c>0&&(d=Math.round(100*(b/c)),100===d?T(e):_(e),$(a,d))
+},updateTotalProgress:function(a,b){this.updateProgress(null,a,b)},hideProgress:function(a){var b=N(a);b&&T(b)},hideTotalProgress:function(){this.hideProgress()},resetProgress:function(a){$(a,0),this.hideTotalProgress(a)},resetTotalProgress:function(){this.resetProgress()},showCancel:function(a){if(!q){var b=E(a);b&&qq(b).removeClass(v.classes.hide)}},hideCancel:function(a){T(E(a))},isCancel:function(a){return qq(a).hasClass(w.cancel,!0)},allowPause:function(a){_(M(a)),T(F(a))},uploadPaused:function(a){this.setStatusText(a,v.text.paused),this.allowContinueButton(a),T(Q(a))},hidePause:function(a){T(M(a))},isPause:function(a){return qq(a).hasClass(w.pause,!0)},isContinueButton:function(a){return qq(a).hasClass(w.continueButton,!0)},allowContinueButton:function(a){_(F(a)),T(M(a))},uploadContinued:function(a){this.setStatusText(a,""),this.allowPause(a),_(Q(a))},showDeleteButton:function(a){_(H(a))},hideDeleteButton:function(a){T(H(a))},isDeleteButton:function(a){return qq(a).hasClass(w.deleteButton,!0)},isRetry:function(a){return qq(a).hasClass(w.retry,!0)},updateSize:function(a,b){var c=P(a);c&&(_(c),qq(c).setText(b))},setStatusText:function(a,b){var c=R(K(a),w.statusText);c&&(null==b?qq(c).clearText():qq(c).setText(b))},hideSpinner:function(a){qq(K(a)).removeClass(p),T(Q(a))},showSpinner:function(a){qq(K(a)).addClass(p),_(Q(a))},generatePreview:function(a,b){t.push({id:a,optFileOrBlob:b}),!s&&D()},updateThumbnail:function(a,b,c){t.push({update:!0,id:a,thumbnailUrl:b,showWaitingImg:c}),!s&&D()},hasDialog:function(a){return qq.supportedFeatures.dialogElement&&!!G(a)},showDialog:function(a,b,c){var d=G(a),e=R(d,w.dialogMessage),f=d.getElementsByTagName("INPUT")[0],g=R(d,w.dialogCancelButton),h=R(d,w.dialogOkButton),i=new qq.Promise,j=function(){g.removeEventListener("click",k),h&&h.removeEventListener("click",l),i.failure()},k=function(){g.removeEventListener("click",k),d.close()},l=function(){d.removeEventListener("close",j),h.removeEventListener("click",l),d.close(),i.success(f&&f.value)};return d.addEventListener("close",j),g.addEventListener("click",k),h&&h.addEventListener("click",l),f&&(f.value=c),e.textContent=b,d.showModal(),i}})},qq.s3=qq.s3||{},qq.s3.util=qq.s3.util||function(){"use strict";return{AWS_PARAM_PREFIX:"x-amz-meta-",SESSION_TOKEN_PARAM_NAME:"x-amz-security-token",REDUCED_REDUNDANCY_PARAM_NAME:"x-amz-storage-class",REDUCED_REDUNDANCY_PARAM_VALUE:"REDUCED_REDUNDANCY",SERVER_SIDE_ENCRYPTION_PARAM_NAME:"x-amz-server-side-encryption",SERVER_SIDE_ENCRYPTION_PARAM_VALUE:"AES256",getBucket:function(a){var b,c=[/^(?:https?:\/\/)?([a-z0-9.\-_]+)\.s3(?:-[a-z0-9\-]+)?\.amazonaws\.com/i,/^(?:https?:\/\/)?s3(?:-[a-z0-9\-]+)?\.amazonaws\.com\/([a-z0-9.\-_]+)/i,/^(?:https?:\/\/)?([a-z0-9.\-_]+)/i];return qq.each(c,function(c,d){var e=d.exec(a);return e?(b=e[1],!1):void 0}),b},getPolicy:function(a){var b={},c=[],d=a.bucket,e=a.key,f=a.acl,g=a.type,h=new Date,i=a.expectedStatus,j=a.sessionToken,k=a.params,l=qq.s3.util.getSuccessRedirectAbsoluteUrl(a.successRedirectUrl),m=a.minFileSize,n=a.maxFileSize,o=a.reducedRedundancy,p=a.serverSideEncryption;return b.expiration=qq.s3.util.getPolicyExpirationDate(h),c.push({acl:f}),c.push({bucket:d}),g&&c.push({"Content-Type":g}),i&&c.push({success_action_status:i.toString()}),l&&c.push({success_action_redirect:l}),o&&(c.push({}),c[c.length-1][qq.s3.util.REDUCED_REDUNDANCY_PARAM_NAME]=qq.s3.util.REDUCED_REDUNDANCY_PARAM_VALUE),j&&(c.push({}),c[c.length-1][qq.s3.util.SESSION_TOKEN_PARAM_NAME]=j),p&&(c.push({}),c[c.length-1][qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_NAME]=qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_VALUE),c.push({key:e}),qq.each(k,function(a,b){var d=qq.s3.util.AWS_PARAM_PREFIX+a,e={};e[d]=encodeURIComponent(b),c.push(e)}),b.conditions=c,qq.s3.util.enforceSizeLimits(b,m,n),b},refreshPolicyCredentials:function(a,b){var c=!1;qq.each(a.conditions,function(a,d){qq.each(d,function(a){a===qq.s3.util.SESSION_TOKEN_PARAM_NAME&&(d[a]=b,c=!0)})}),c||(a.conditions.push({}),a.conditions[a.conditions.length-1][qq.s3.util.SESSION_TOKEN_PARAM_NAME]=b)},generateAwsParams:function(a,b){var c={},d=a.params,e=new qq.Promise,f=qq.s3.util.getPolicy(a),g=a.sessionToken,h=a.type,i=a.key,j=a.accessKey,k=a.acl,l=a.expectedStatus,m=qq.s3.util.getSuccessRedirectAbsoluteUrl(a.successRedirectUrl),n=a.reducedRedundancy,o=a.serverSideEncryption,p=a.log;return c.key=i,c.AWSAccessKeyId=j,h&&(c["Content-Type"]=h),l&&(c.success_action_status=l),m&&(c.success_action_redirect=m),n&&(c[qq.s3.util.REDUCED_REDUNDANCY_PARAM_NAME]=qq.s3.util.REDUCED_REDUNDANCY_PARAM_VALUE),o&&(c[qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_NAME]=qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_VALUE),g&&(c[qq.s3.util.SESSION_TOKEN_PARAM_NAME]=g),c.acl=k,qq.each(d,function(a,b){var d=qq.s3.util.AWS_PARAM_PREFIX+a;c[d]=encodeURIComponent(b)}),b(f).then(function(a,b,d){c.policy=a.policy,c.signature=a.signature,b&&(c.AWSAccessKeyId=b),d&&(c[qq.s3.util.SESSION_TOKEN_PARAM_NAME]=d),e.success(c)},function(a){a=a||"Can't continue further with request to S3 as we did not receive a valid signature and policy from the server.",p("Policy signing failed.  "+a,"error"),e.failure(a)}),e},enforceSizeLimits:function(a,b,c){var d=0>b?0:b,e=0>=c?9007199254740992:c;(b>0||c>0)&&a.conditions.push(["content-length-range",d.toString(),e.toString()])},getPolicyExpirationDate:function(a){if(a.setMinutes(a.getMinutes()+5),Date.prototype.toISOString)return a.toISOString();var b=function(a){var b=String(a);return 1===b.length&&(b="0"+b),b};return a.getUTCFullYear()+"-"+b(a.getUTCMonth()+1)+"-"+b(a.getUTCDate())+"T"+b(a.getUTCHours())+":"+b(a.getUTCMinutes())+":"+b(a.getUTCSeconds())+"."+String((a.getUTCMilliseconds()/1e3).toFixed(3)).slice(2,5)+"Z"},parseIframeResponse:function(a){var b=a.contentDocument||a.contentWindow.document,c=b.location.search,d=/bucket=(.+)&key=(.+)&etag=(.+)/.exec(c);return d?{bucket:d[1],key:d[2],etag:d[3].replace(/%22/g,"")}:void 0},getSuccessRedirectAbsoluteUrl:function(a){if(a){var b,c=document.createElement("div");return qq.ie7()?(c.innerHTML="<a href='"+a+"'></a>",b=c.firstChild,b.href):(b=document.createElement("a"),b.href=a,b.href=b.href,b.href)}},encodeQueryStringParam:function(a){var b=encodeURIComponent(a);return b=b.replace(/[!'()]/g,escape),b=b.replace(/\*/g,"%2A"),b.replace(/%20/g,"+")}}}(),function(){"use strict";qq.nonTraditionalBasePublicApi={setUploadSuccessParams:function(a,b){this._uploadSuccessParamsStore.set(a,b)},setUploadSuccessEndpoint:function(a,b){this._uploadSuccessEndpointStore.set(a,b)}},qq.nonTraditionalBasePrivateApi={_onComplete:function(a,b,c,d){var e,f,g=c.success?!0:!1,h=this,i=arguments,j=this._uploadSuccessEndpointStore.get(a),k=this._options.uploadSuccess.customHeaders,l=this._options.uploadSuccess.method,m=this._options.cors,n=new qq.Promise,o=this._uploadSuccessParamsStore.get(a),p=this._paramsStore.get(a),q=function(b){delete h._failedSuccessRequestCallbacks[a],qq.extend(c,b),qq.FineUploaderBasic.prototype._onComplete.apply(h,i),n.success(b)},r=function(f){var g=e;qq.extend(c,f),c&&c.reset&&(g=null),g?h._failedSuccessRequestCallbacks[a]=g:delete h._failedSuccessRequestCallbacks[a],h._onAutoRetry(a,b,c,d,g)||(qq.FineUploaderBasic.prototype._onComplete.apply(h,i),n.failure(f))};return g&&j?(f=new qq.UploadSuccessAjaxRequester({endpoint:j,method:l,customHeaders:k,cors:m,log:qq.bind(this.log,this)}),qq.extend(o,h._getEndpointSpecificParams(a,c,d),!0),p&&qq.extend(o,p,!0),e=qq.bind(function(){f.sendSuccessRequest(a,o).then(q,r)},h),e(),n):qq.FineUploaderBasic.prototype._onComplete.apply(this,arguments)},_manualRetry:function(a){var b=this._failedSuccessRequestCallbacks[a];return qq.FineUploaderBasic.prototype._manualRetry.call(this,a,b)}}}(),function(){"use strict";qq.s3.FineUploaderBasic=function(a){var b={request:{accessKey:null},objectProperties:{acl:"private",bucket:qq.bind(function(a){return qq.s3.util.getBucket(this.getEndpoint(a))},this),key:"uuid",reducedRedundancy:!1,serverSideEncryption:!1},credentials:{accessKey:null,secretKey:null,expiration:null,sessionToken:null},signature:{endpoint:null,customHeaders:{}},uploadSuccess:{endpoint:null,method:"POST",params:{},customHeaders:{}},iframeSupport:{localBlankPagePath:null},chunking:{partSize:5242880},cors:{allowXdr:!0},callbacks:{onCredentialsExpired:function(){}}};qq.extend(b,a,!0),this.setCredentials(b.credentials,!0)||(this._currentCredentials.accessKey=b.request.accessKey),this._aclStore=this._createStore(b.objectProperties.acl),qq.FineUploaderBasic.call(this,b),this._uploadSuccessParamsStore=this._createStore(this._options.uploadSuccess.params),this._uploadSuccessEndpointStore=this._createStore(this._options.uploadSuccess.endpoint),this._failedSuccessRequestCallbacks={},this._cannedKeys={},this._cannedBuckets={},this._buckets={}},qq.extend(qq.s3.FineUploaderBasic.prototype,qq.basePublicApi),qq.extend(qq.s3.FineUploaderBasic.prototype,qq.basePrivateApi),qq.extend(qq.s3.FineUploaderBasic.prototype,qq.nonTraditionalBasePublicApi),qq.extend(qq.s3.FineUploaderBasic.prototype,qq.nonTraditionalBasePrivateApi),qq.extend(qq.s3.FineUploaderBasic.prototype,{getBucket:function(a){return null==this._cannedBuckets[a]?this._buckets[a]:this._cannedBuckets[a]},getKey:function(a){return null==this._cannedKeys[a]?this._handler.getThirdPartyFileId(a):this._cannedKeys[a]},reset:function(){qq.FineUploaderBasic.prototype.reset.call(this),this._failedSuccessRequestCallbacks=[],this._buckets={}},setCredentials:function(a,b){if(a&&a.secretKey){if(!a.accessKey)throw new qq.Error("Invalid credentials: no accessKey");if(!a.expiration)throw new qq.Error("Invalid credentials: no expiration");return this._currentCredentials=qq.extend({},a),qq.isString(a.expiration)&&(this._currentCredentials.expiration=new Date(a.expiration)),!0}if(!b)throw new qq.Error("Invalid credentials parameter!");this._currentCredentials={}},setAcl:function(a,b){this._aclStore.set(a,b)},_createUploadHandler:function(){var a=this,b={aclStore:this._aclStore,getBucket:qq.bind(this._determineBucket,this),getKeyName:qq.bind(this._determineKeyName,this),iframeSupport:this._options.iframeSupport,objectProperties:this._options.objectProperties,signature:this._options.signature,validation:{minSizeLimit:this._options.validation.minSizeLimit,maxSizeLimit:this._options.validation.sizeLimit}};return qq.override(this._endpointStore,function(a){return{get:function(b){var c=a.get(b);return c.indexOf("http")<0?"http://"+c:c}}}),qq.override(this._paramsStore,function(a){return{get:function(b){var c=a.get(b),d={};return qq.each(c,function(a,b){d[a.toLowerCase()]=qq.isFunction(b)?b():b}),d}}}),b.signature.credentialsProvider={get:function(){return a._currentCredentials},onExpired:function(){var b=new qq.Promise,c=a._options.callbacks.onCredentialsExpired();return qq.isGenericPromise(c)?c.then(function(c){try{a.setCredentials(c),b.success()}catch(d){a.log("Invalid credentials returned from onCredentialsExpired callback! ("+d.message+")","error"),b.failure("onCredentialsExpired did not return valid credentials.")}},function(c){a.log("onCredentialsExpired callback indicated failure! ("+c+")","error"),b.failure("onCredentialsExpired callback failed.")}):(a.log("onCredentialsExpired callback did not return a promise!","error"),b.failure("Unexpected return value for onCredentialsExpired.")),b}},qq.FineUploaderBasic.prototype._createUploadHandler.call(this,b,"s3")},_determineBucket:function(a){var b=this._options.objectProperties.bucket,c=new qq.Promise,d=this;return qq.isFunction(b)?(b=b(a),qq.isGenericPromise(b)?c=b:c.success(b)):qq.isString(b)&&c.success(b),c.then(function(b){d._buckets[a]=b},function(b){qq.log("Problem determining bucket for ID "+a+" ("+b+")","error")}),c},_determineKeyName:function(a,b){var c=new qq.Promise,d=this._options.objectProperties.key,e=qq.getExtension(b),f=c.failure,g=function(a,b){var d=a;void 0!==b&&(d+="."+b),c.success(d)};switch(d){case"uuid":g(this.getUuid(a),e);break;case"filename":g(b);break;default:qq.isFunction(d)?this._handleKeynameFunction(d,a,g,f):(this.log(d+" is not a valid value for the s3.keyname option!","error"),f())}return c},_handleKeynameFunction:function(a,b,c,d){var e=this,f=function(a){c(a)},g=function(a){e.log(qq.format("Failed to retrieve key name for {}.  Reason: {}",b,a||"null"),"error"),d(a)},h=a.call(this,b);qq.isGenericPromise(h)?h.then(f,g):null==h?g():f(h)},_getEndpointSpecificParams:function(a,b,c){var d={key:this.getKey(a),uuid:this.getUuid(a),name:this.getName(a),bucket:this.getBucket(a)};return c&&c.getResponseHeader("ETag")?d.etag=c.getResponseHeader("ETag"):b.etag&&(d.etag=b.etag),d},_onSubmitDelete:function(a,b){var c={key:this.getKey(a),bucket:this.getBucket(a)};return qq.FineUploaderBasic.prototype._onSubmitDelete.call(this,a,b,c)},_addCannedFile:function(a){var b;if(null==a.s3Key)throw new qq.Error("Did not find s3Key property in server session response.  This is required!");return b=qq.FineUploaderBasic.prototype._addCannedFile.apply(this,arguments),this._cannedKeys[b]=a.s3Key,this._cannedBuckets[b]=a.s3Bucket,b}})}(),qq.s3.RequestSigner=function(a){"use strict";function b(a,b,c){var d,e,f=b.responseText,g=j[a],h=g.promise;if(delete j[a],f)try{e=qq.parseJson(f)}catch(i){k.log("Error attempting to parse signature response: "+i,"error")}e&&e.invalid?(c=!0,d="Invalid policy document or request headers!"):e?k.expectingPolicy&&!e.policy?(c=!0,d="Response does not include the base64 encoded policy!"):e.signature||(c=!0,d="Response does not include the signature!"):(c=!0,d="Received an empty or invalid response from the server!"),c?(d&&k.log(d,"error"),h.failure(d)):h.success(e)}function c(a,b,c,d,e,f,g){var h,j="POST",k=[],l="";switch(a){case i.REQUEST_TYPE.MULTIPART_ABORT:j="DELETE",h=qq.format("uploadId={}",f);break;case i.REQUEST_TYPE.MULTIPART_INITIATE:h="uploads";break;case i.REQUEST_TYPE.MULTIPART_COMPLETE:h=qq.format("uploadId={}",f);break;case i.REQUEST_TYPE.MULTIPART_UPLOAD:j="PUT",h=qq.format("partNumber={}&uploadId={}",g,f)}return h=c+"?"+h,qq.each(e,function(a){k.push(a)}),k.sort(),qq.each(k,function(a,b){l+=b+":"+e[b]+"\n"}),{toSign:qq.format("{}\n\n{}\n\n{}/{}/{}",j,d||"",l||"\n",b,h),endOfUrl:h}}function d(a,b,c,d){var g;a.signatureConstructor?(d&&(g=a.signatureConstructor.getHeaders(),g[qq.s3.util.SESSION_TOKEN_PARAM_NAME]=d,a.signatureConstructor.withHeaders(g)),f(a.signatureConstructor.getToSign().stringToSign,b)):(d&&qq.s3.util.refreshPolicyCredentials(a,d),e(a,b,c,d))}function e(a,b,c,d){var e=JSON.stringify(a),f=CryptoJS.enc.Utf8.parse(e),g=CryptoJS.enc.Base64.stringify(f),i=CryptoJS.HmacSHA1(g,h.get().secretKey),j=CryptoJS.enc.Base64.stringify(i);b.success({policy:g,signature:j},c,d)}function f(a,b){var c=CryptoJS.enc.Utf8.parse(a),d=CryptoJS.HmacSHA1(c,h.get().secretKey),e=CryptoJS.enc.Base64.stringify(d);b.success({signature:e})}var g,h,i=this,j={},k={expectingPolicy:!1,method:"POST",signatureSpec:{credentialsProvider:{},endpoint:null,customHeaders:{}},maxConnections:3,paramsStore:{},cors:{expected:!1,sendCredentials:!1},log:function(){}};qq.extend(k,a,!0),h=k.signatureSpec.credentialsProvider,g=qq.extend(this,new qq.AjaxRequester({acceptHeader:"application/json",method:k.method,contentType:"application/json; charset=utf-8",endpointStore:{get:function(){return k.signatureSpec.endpoint}},paramsStore:k.paramsStore,maxConnections:k.maxConnections,customHeaders:k.signatureSpec.customHeaders,log:k.log,onComplete:b,cors:k.cors})),qq.extend(this,{getSignature:function(a,b){var c=b,e=new qq.Promise;return h.get().secretKey&&window.CryptoJS?h.get().expiration.getTime()>Date.now()?d(b,e):h.onExpired().then(function(){d(b,e,h.get().accessKey,h.get().sessionToken)},function(){k.log("Attempt to update expired credentials apparently failed! Unable to sign request.  ","error"),e.failure("Unable to sign request - expired credentials.")}):(k.log("Submitting S3 signature request for "+a),c.signatureConstructor&&(c={headers:c.signatureConstructor.getToSign().stringToSign}),g.initTransport(a).withParams(c).send(),j[a]={promise:e}),e},constructStringToSign:function(a,b,d){var e,f,g,i,j={};return{withHeaders:function(a){return j=a,this},withUploadId:function(a){return e=a,this},withContentType:function(a){return f=a,this},withPartNum:function(a){return g=a,this},getToSign:function(){var k=h.get().sessionToken;return j["x-amz-date"]=(new Date).toUTCString(),k&&(j[qq.s3.util.SESSION_TOKEN_PARAM_NAME]=k),i=c(a,b,d,f,j,e,g),{headers:function(){return f&&(j["Content-Type"]=f),j}(),endOfUrl:i.endOfUrl,stringToSign:i.toSign}},getHeaders:function(){return qq.extend({},j)},getEndOfUrl:function(){return i&&i.endOfUrl}}}})},qq.s3.RequestSigner.prototype.REQUEST_TYPE={MULTIPART_INITIATE:"multipart_initiate",MULTIPART_COMPLETE:"multipart_complete",MULTIPART_ABORT:"multipart_abort",MULTIPART_UPLOAD:"multipart_upload"},qq.UploadSuccessAjaxRequester=function(a){"use strict";function b(a,b,c){var f,g=d[a],h=b.responseText,i={success:!0},j={success:!1};delete d[a],e.log(qq.format("Received the following response body to an upload success request for id {}: {}",a,h));try{f=qq.parseJson(h),c||f&&(f.error||f.success===!1)?(e.log("Upload success request was rejected by the server.","error"),g.failure(qq.extend(f,j))):(e.log("Upload success was acknowledged by the server."),g.success(qq.extend(f,i)))}catch(k){c?(e.log(qq.format("Your server indicated failure in its upload success request response for id {}!",a),"error"),g.failure(j)):(e.log("Upload success was acknowledged by the server."),g.success(i))}}var c,d=[],e={method:"POST",endpoint:null,maxConnections:3,customHeaders:{},paramsStore:{},cors:{expected:!1,sendCredentials:!1},log:function(){}};qq.extend(e,a),c=qq.extend(this,new qq.AjaxRequester({acceptHeader:"application/json",method:e.method,endpointStore:{get:function(){return e.endpoint}},paramsStore:e.paramsStore,maxConnections:e.maxConnections,customHeaders:e.customHeaders,log:e.log,onComplete:b,cors:e.cors})),qq.extend(this,{sendSuccessRequest:function(a,b){var f=new qq.Promise;return e.log("Submitting upload success request/notification for "+a),c.initTransport(a).withParams(b).send(),d[a]=f,f}})},qq.s3.InitiateMultipartAjaxRequester=function(a){"use strict";function b(a){var b,c=g.getBucket(a),d={},f=new qq.Promise,h=g.getKey(a);return d["x-amz-acl"]=g.aclStore.get(a),g.reducedRedundancy&&(d[qq.s3.util.REDUCED_REDUNDANCY_PARAM_NAME]=qq.s3.util.REDUCED_REDUNDANCY_PARAM_VALUE),g.serverSideEncryption&&(d[qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_NAME]=qq.s3.util.SERVER_SIDE_ENCRYPTION_PARAM_VALUE),d[qq.s3.util.AWS_PARAM_PREFIX+g.filenameParam]=encodeURIComponent(g.getName(a)),qq.each(g.paramsStore.get(a),function(a,b){d[qq.s3.util.AWS_PARAM_PREFIX+a]=encodeURIComponent(b)}),b=e.constructStringToSign(e.REQUEST_TYPE.MULTIPART_INITIATE,c,h).withContentType(g.getContentType(a)).withHeaders(d),e.getSignature(a,{signatureConstructor:b}).then(function(a){d=b.getHeaders(),d.Authorization="AWS "+g.signatureSpec.credentialsProvider.get().accessKey+":"+a.signature,f.success(d,b.getEndOfUrl())},f.failure),f}function c(a,b,c){var d,e,h,i,j,k=f[a],l=new DOMParser,m=l.parseFromString(b.responseText,"application/xml");delete f[a],c?(j=b.status,e=m.getElementsByTagName("Message"),e.length>0&&(i=e[0].textContent)):(d=m.getElementsByTagName("UploadId"),d.length>0?h=d[0].textContent:i="Upload ID missing from request"),void 0===h?(i?g.log(qq.format("Specific problem detected initiating multipart upload request for {}: '{}'.",a,i),"error"):g.log(qq.format("Unexplained error with initiate multipart upload request for {}.  Status code {}.",a,j),"error"),k.failure("Problem initiating upload request.",b)):(g.log(qq.format("Initiate multipart upload request successful for {}.  Upload ID is {}",a,h)),k.success(h,b))}var d,e,f={},g={filenameParam:"qqfilename",method:"POST",endpointStore:null,paramsStore:null,signatureSpec:null,aclStore:null,reducedRedundancy:!1,serverSideEncryption:!1,maxConnections:3,getContentType:function(){},getBucket:function(){},getKey:function(){},getName:function(){},log:function(){}};qq.extend(g,a),e=new qq.s3.RequestSigner({signatureSpec:g.signatureSpec,cors:g.cors,log:g.log}),d=qq.extend(this,new qq.AjaxRequester({method:g.method,contentType:null,endpointStore:g.endpointStore,maxConnections:g.maxConnections,allowXRequestedWithAndCacheControl:!1,log:g.log,onComplete:c,successfulResponseCodes:{POST:[200]}})),qq.extend(this,{send:function(a){var c=new qq.Promise;return b(a).then(function(b,e){g.log("Submitting S3 initiate multipart upload request for "+a),f[a]=c,d.initTransport(a).withPath(e).withHeaders(b).send()},c.failure),c}})},qq.s3.CompleteMultipartAjaxRequester=function(a){"use strict";function b(a,b){var c={},d=new qq.Promise,e=h.getBucket(a),g=f.constructStringToSign(f.REQUEST_TYPE.MULTIPART_COMPLETE,e,h.getKey(a)).withUploadId(b).withContentType("application/xml; charset=UTF-8");return f.getSignature(a,{signatureConstructor:g}).then(function(a){c=g.getHeaders(),c.Authorization="AWS "+h.signatureSpec.credentialsProvider.get().accessKey+":"+a.signature,d.success(c,g.getEndOfUrl())},d.failure),d}function c(a,b,c){var d=g[a],e=new DOMParser,f=h.getBucket(a),i=(h.getKey(a),e.parseFromString(b.responseText,"application/xml")),j=i.getElementsByTagName("Bucket"),k=i.getElementsByTagName("Key");delete g[a],h.log(qq.format("Complete response status {}, body = {}",b.status,b.responseText)),c?h.log(qq.format("Complete Multipart Upload request for {} failed with status {}.",a,b.status),"error"):j.length&&k.length?j[0].textContent!==f&&(c=!0,h.log(qq.format("Wrong bucket in response to Complete Multipart Upload request for {}.",a),"error")):(c=!0,h.log(qq.format("Missing bucket and/or key in response to Complete Multipart Upload request for {}.",a),"error")),c?d.failure("Problem combining the file parts!",b):d.success({},b)}function d(a){var b=document.implementation.createDocument(null,"CompleteMultipartUpload",null);return a.sort(function(a,b){return a.part-b.part}),qq.each(a,function(a,c){var d=c.part,e=c.etag,f=b.createElement("Part"),g=b.createElement("PartNumber"),h=b.createTextNode(d),i=b.createTextNode(e),j=b.createElement("ETag");j.appendChild(i),g.appendChild(h),f.appendChild(g),f.appendChild(j),qq(b).children()[0].appendChild(f)}),(new XMLSerializer).serializeToString(b)}var e,f,g={},h={method:"POST",contentType:"text/xml",endpointStore:null,signatureSpec:null,maxConnections:3,getBucket:function(){},getKey:function(){},log:function(){}};qq.extend(h,a),f=new qq.s3.RequestSigner({signatureSpec:h.signatureSpec,cors:h.cors,log:h.log}),e=qq.extend(this,new qq.AjaxRequester({method:h.method,contentType:"application/xml; charset=UTF-8",endpointStore:h.endpointStore,maxConnections:h.maxConnections,allowXRequestedWithAndCacheControl:!1,log:h.log,onComplete:c,successfulResponseCodes:{POST:[200]}})),qq.extend(this,{send:function(a,c,f){var i=new qq.Promise;return b(a,c).then(function(b,c){var j=d(f);h.log("Submitting S3 complete multipart upload request for "+a),g[a]=i,delete b["Content-Type"],e.initTransport(a).withPath(c).withHeaders(b).withPayload(j).send()},i.failure),i}})},qq.s3.AbortMultipartAjaxRequester=function(a){"use strict";function b(a,b){var c={},d=new qq.Promise,g=(f.endpointStore.get(a),f.getBucket(a)),h=e.constructStringToSign(e.REQUEST_TYPE.MULTIPART_ABORT,g,f.getKey(a)).withUploadId(b);return e.getSignature(a,{signatureConstructor:h}).then(function(a){c=h.getHeaders(),c.Authorization="AWS "+f.signatureSpec.credentialsProvider.get().accessKey+":"+a.signature,d.success(c,h.getEndOfUrl())},d.failure),d}function c(a,b,c){var d,e=new DOMParser,g=e.parseFromString(b.responseText,"application/xml"),h=g.getElementsByTagName("Error");f.log(qq.format("Abort response status {}, body = {}",b.status,b.responseText)),c?f.log(qq.format("Abort Multipart Upload request for {} failed with status {}.",a,b.status),"error"):h.length?(c=!0,d=g.getElementsByTagName("Message")[0].textContent,f.log(qq.format("Failed to Abort Multipart Upload request for {}.  Error: {}",a,d),"error")):f.log(qq.format("Abort MPU request succeeded for file ID {}.",a))}var d,e,f={method:"DELETE",endpointStore:null,signatureSpec:null,maxConnections:3,getBucket:function(){},getKey:function(){},log:function(){}};qq.extend(f,a),e=new qq.s3.RequestSigner({signatureSpec:f.signatureSpec,cors:f.cors,log:f.log}),d=qq.extend(this,new qq.AjaxRequester({validMethods:["DELETE"],method:f.method,contentType:null,endpointStore:f.endpointStore,maxConnections:f.maxConnections,allowXRequestedWithAndCacheControl:!1,log:f.log,onComplete:c,successfulResponseCodes:{DELETE:[204]}})),qq.extend(this,{send:function(a,c){b(a,c).then(function(b,c){f.log("Submitting S3 Abort multipart upload request for "+a),d.initTransport(a).withPath(c).withHeaders(b).send()})}})},qq.s3.XhrUploadHandler=function(a,b){"use strict";var c=b.getName,d=b.log,e=200,f=a.getBucket,g=a.getKeyName,h=a.filenameParam,i=a.paramsStore,j=a.endpointStore,k=a.aclStore,l=a.objectProperties.reducedRedundancy,m=a.objectProperties.serverSideEncryption,n=a.validation,o=a.signature,p=this,q=a.signature.credentialsProvider,r={combine:function(a){var b=p._getPersistableData(a).uploadId,c=p._getPersistableData(a).etags,d=new qq.Promise;return s.completeMultipart.send(a,b,c).then(d.success,function(b,c){d.failure(u.done(a,c).response,c)}),d},done:function(a,b,c){var d,e=u.response.parse(a,b);e.success&&(d=b.getResponseHeader("ETag"),p._getPersistableData(a).etags||(p._getPersistableData(a).etags=[]),p._getPersistableData(a).etags.push({part:c+1,etag:d}))},initHeaders:function(b,c){var d={},e=(a.endpointStore.get(b),u.bucket.getName(b)),f=u.key.urlSafe(b),g=new qq.Promise,h=s.restSignature.constructStringToSign(s.restSignature.REQUEST_TYPE.MULTIPART_UPLOAD,e,f).withPartNum(c+1).withUploadId(p._getPersistableData(b).uploadId);return s.restSignature.getSignature(b+"."+c,{signatureConstructor:h}).then(function(a){d=h.getHeaders(),d.Authorization="AWS "+q.get().accessKey+":"+a.signature,g.success(d,h.getEndOfUrl())},g.failure),g},put:function(b,c){var d=p._createXhr(b,c),e=p._getChunkData(b,c),f=a.endpointStore.get(b),g=new qq.Promise;return r.initHeaders(b,c).then(function(a,h){var i=f+"/"+h;p._registerProgressHandler(b,c,e.size),u.track(b,d,c).then(g.success,g.failure),d.open("PUT",i,!0),qq.each(a,function(a,b){d.setRequestHeader(a,b)}),d.send(e.blob)},function(){g.failure({error:"Problem signing the chunk!"},d)}),g},send:function(a,b){var c=new qq.Promise;return r.setup(a).then(function(){r.put(a,b).then(c.success,c.failure)},function(a,b){c.failure({error:a},b)}),c},setup:function(a){var b=new qq.Promise,c=p._getPersistableData(a).uploadId,d=new qq.Promise;return c?c instanceof qq.Promise?c.then(function(a){b.success(a)}):b.success(c):(p._getPersistableData(a).uploadId=d,s.initiateMultipart.send(a).then(function(c){p._getPersistableData(a).uploadId=c,d.success(c),b.success(c)},function(c){p._getPersistableData(a).uploadId=null,b.failure(c),d.failure(c)})),b}},s={abortMultipart:new qq.s3.AbortMultipartAjaxRequester({endpointStore:j,signatureSpec:o,cors:a.cors,log:d,getBucket:function(a){return u.bucket.getName(a)},getKey:function(a){return u.key.urlSafe(a)}}),completeMultipart:new qq.s3.CompleteMultipartAjaxRequester({endpointStore:j,signatureSpec:o,cors:a.cors,log:d,getBucket:function(a){return u.bucket.getName(a)},getKey:function(a){return u.key.urlSafe(a)}}),initiateMultipart:new qq.s3.InitiateMultipartAjaxRequester({filenameParam:h,endpointStore:j,paramsStore:i,signatureSpec:o,aclStore:k,reducedRedundancy:l,serverSideEncryption:m,cors:a.cors,log:d,getContentType:function(a){return p._getMimeType(a)},getBucket:function(a){return u.bucket.getName(a)},getKey:function(a){return u.key.urlSafe(a)},getName:function(a){return c(a)}}),policySignature:new qq.s3.RequestSigner({expectingPolicy:!0,signatureSpec:o,cors:a.cors,log:d}),restSignature:new qq.s3.RequestSigner({signatureSpec:o,cors:a.cors,log:d})},t={initParams:function(a){var b=i.get(a);return b[h]=c(a),qq.s3.util.generateAwsParams({endpoint:j.get(a),params:b,type:p._getMimeType(a),bucket:u.bucket.getName(a),key:p.getThirdPartyFileId(a),accessKey:q.get().accessKey,sessionToken:q.get().sessionToken,acl:k.get(a),expectedStatus:e,minFileSize:n.minSizeLimit,maxFileSize:n.maxSizeLimit,reducedRedundancy:l,serverSideEncryption:m,log:d},qq.bind(s.policySignature.getSignature,this,a))},send:function(a){var b=new qq.Promise,c=p._createXhr(a),e=p.getFile(a);return p._registerProgressHandler(a),u.track(a,c).then(b.success,b.failure),t.setup(a,c,e).then(function(b){d("Sending upload request for "+a),c.send(b)},b.failure),b},setup:function(a,b,c){var d=new FormData,e=j.get(a),f=e,g=new qq.Promise;return t.initParams(a).then(function(a){b.open("POST",f,!0),qq.obj2FormData(a,d),d.append("file",c),g.success(d)},function(a){g.failure({error:a})}),g}},u={bucket:{promise:function(a){var b=new qq.Promise,c=p._getFileState(a).bucket;return c?b.success(c):f(a).then(function(c){p._getFileState(a).bucket=c,b.success(c)},b.failure),b},getName:function(a){return p._getFileState(a).bucket}},done:function(a,b){var c=u.response.parse(a,b),e=c.success!==!0;return e&&u.response.shouldReset(c.code)&&(d("This is an unrecoverable error, we must restart the upload entirely on the next retry attempt.","error"),c.reset=!0),{success:!e,response:c}},key:{promise:function(a){var b=new qq.Promise,d=p.getThirdPartyFileId(a);return null==d?(p._setThirdPartyFileId(a,b),g(a,c(a)).then(function(c){p._setThirdPartyFileId(a,c),b.success(c)},function(c){p._setThirdPartyFileId(a,null),b.failure(c)})):qq.isGenericPromise(d)?d.then(b.success,b.failure):b.success(d),b},urlSafe:function(a){return encodeURIComponent(p.getThirdPartyFileId(a))}},response:{parse:function(a,b){var c,f={};try{d(qq.format("Received response status {} with body: {}",b.status,b.responseText)),b.status===e?f.success=!0:(c=u.response.parseError(b.responseText),c&&(f.error=c.message,f.code=c.code))}catch(g){d("Error when attempting to parse xhr response text ("+g.message+")","error")}return f},parseError:function(a){var b,c,d=new DOMParser,e=d.parseFromString(a,"application/xml"),f=e.getElementsByTagName("Error"),g={};return f.length?(b=e.getElementsByTagName("Code"),c=e.getElementsByTagName("Message"),c.length&&(g.message=c[0].textContent),b.length&&(g.code=b[0].textContent),g):void 0},shouldReset:function(a){return"EntityTooSmall"===a||"InvalidPart"===a||"InvalidPartOrder"===a||"NoSuchUpload"===a}},start:function(a,b){var c=new qq.Promise;return u.key.promise(a).then(function(){u.bucket.promise(a).then(function(){null==b?t.send(a).then(c.success,c.failure):r.send(a,b).then(c.success,c.failure)})},function(a){c.failure({error:a})}),c},track:function(a,b,c){var d=new qq.Promise;return b.onreadystatechange=function(){if(4===b.readyState){var e;null==c?(e=u.done(a,b),d[e.success?"success":"failure"](e.response,b)):(r.done(a,b,c),e=u.done(a,b),d[e.success?"success":"failure"](e.response,b))}},d}};qq.extend(this,{uploadChunk:u.start,uploadFile:u.start}),qq.extend(this,new qq.XhrUploadHandler({options:qq.extend({namespace:"s3"},a),proxy:qq.extend({getEndpoint:a.endpointStore.get},b)})),qq.override(this,function(a){return{expunge:function(b){var c=p._getPersistableData(b)&&p._getPersistableData(b).uploadId,d=p._maybeDeletePersistedChunkData(b);void 0!==c&&d&&s.abortMultipart.send(b,c),a.expunge(b)},finalizeChunks:function(a){return r.combine(a)},_getLocalStorageId:function(b){var c=a._getLocalStorageId(b),d=u.bucket.getName(b);return c+"-"+d}}})},qq.s3.FormUploadHandler=function(a,b){"use strict";function c(b,c){var d,e,f,g=a.endpointStore.get(b),i=qq.s3.util.getBucket(g);try{if(d=c.contentDocument||c.contentWindow.document,e=d.body.innerHTML,f=qq.s3.util.parseIframeResponse(c),f.bucket===i&&f.key===qq.s3.util.encodeQueryStringParam(h.getThirdPartyFileId(b)))return!0;l("Response from AWS included an unexpected bucket or key name.","error")}catch(j){l("Error when attempting to parse form upload response ("+j.message+")","error")}return!1}function d(a){var b=p.get(a);return b[o]=j(a),qq.s3.util.generateAwsParams({endpoint:q.get(a),params:b,bucket:h._getFileState(a).bucket,key:h.getThirdPartyFileId(a),accessKey:x.get().accessKey,sessionToken:x.get().sessionToken,acl:r.get(a),minFileSize:u.minSizeLimit,maxFileSize:u.maxSizeLimit,successRedirectUrl:w,reducedRedundancy:s,serverSideEncryption:t,log:l},qq.bind(y.getSignature,this,a))
+}function e(b,c){var e=new qq.Promise,f="POST",i=a.endpointStore.get(b),k=j(b);return d(b).then(function(a){var b=h._initFormForUpload({method:f,endpoint:i,params:a,paramsInBody:!0,targetName:c.name});e.success(b)},function(a){e.failure(a),g(b,c,k,{error:a})}),e}function f(a){var b=h._createIframe(a),d=h.getInput(a),f=new qq.Promise;return e(a,b).then(function(e){e.appendChild(d),h._attachLoadEvent(b,function(d){l("iframe loaded"),d?d.success===!1&&(l("Amazon likely rejected the upload request","error"),f.failure(d)):(d={},d.success=c(a,b),d.success===!1?(l("A success response was received by Amazon, but it was invalid in some way.","error"),f.failure(d)):(qq.extend(d,qq.s3.util.parseIframeResponse(b)),f.success(d))),g(a,b)}),l("Sending upload request for "+a),e.submit(),qq(e).remove()},f.failure),f}function g(a,b){h._detachLoadEvent(a),b&&qq(b).remove()}var h=this,i=b.onUuidChanged,j=b.getName,k=b.getUuid,l=b.log,m=a.getBucket,n=a.getKeyName,o=a.filenameParam,p=a.paramsStore,q=a.endpointStore,r=a.aclStore,s=a.objectProperties.reducedRedundancy,t=a.objectProperties.serverSideEncryption,u=a.validation,v=a.signature,w=a.iframeSupport.localBlankPagePath,x=a.signature.credentialsProvider,y=new qq.s3.RequestSigner({signatureSpec:v,cors:a.cors,log:l});if(void 0===w)throw new Error("successRedirectEndpoint MUST be defined if you intend to use browsers that do not support the File API!");qq.extend(this,new qq.FormUploadHandler({options:{isCors:!1,inputName:"file"},proxy:{onCancel:a.onCancel,onUuidChanged:i,getName:j,getUuid:k,log:l}})),qq.extend(this,{uploadFile:function(a){var b=j(a),c=new qq.Promise;return h.getThirdPartyFileId(a)?h._getFileState(a).bucket?f(a).then(c.success,c.failure):m(a).then(function(b){h._getFileState(a).bucket=b,f(a).then(c.success,c.failure)}):n(a,b).then(function(b){m(a).then(function(d){h._getFileState(a).bucket=d,h._setThirdPartyFileId(a,b),f(a).then(c.success,c.failure)},function(a){c.failure({error:a})})},function(a){c.failure({error:a})}),c}})},function(){"use strict";qq.s3.FineUploader=function(a){var b={failedUploadTextDisplay:{mode:"custom"}};qq.extend(b,a,!0),qq.FineUploader.call(this,b,"s3"),qq.supportedFeatures.ajaxUploading||void 0!==b.iframeSupport.localBlankPagePath||(this._options.element.innerHTML="<div>You MUST set the <code>localBlankPagePath</code> property of the <code>iframeSupport</code> option since this browser does not support the File API!</div>")},qq.extend(qq.s3.FineUploader.prototype,qq.s3.FineUploaderBasic.prototype),qq.extend(qq.s3.FineUploader.prototype,qq.uiPublicApi),qq.extend(qq.s3.FineUploader.prototype,qq.uiPrivateApi)}(),qq.PasteSupport=function(a){"use strict";function b(a){return a.type&&0===a.type.indexOf("image/")}function c(){f=qq(e.targetElement).attach("paste",function(a){var c=a.clipboardData;c&&qq.each(c.items,function(a,c){if(b(c)){var d=c.getAsFile();e.callbacks.pasteReceived(d)}})})}function d(){f&&f()}var e,f;e={targetElement:null,callbacks:{log:function(){},pasteReceived:function(){}}},qq.extend(e,a),c(),qq.extend(this,{reset:function(){d()}})},qq.DragAndDrop=function(a){"use strict";function b(a,b){var c=Array.prototype.slice.call(a);j.callbacks.dropLog("Grabbed "+a.length+" dropped files."),b.dropDisabled(!1),j.callbacks.processingDroppedFilesComplete(c,b.getElement())}function c(a){var b=new qq.Promise;return a.isFile?a.file(function(c){var d=a.name,e=a.fullPath,f=e.indexOf(d);e=e.substr(0,f),"/"===e.charAt(0)&&(e=e.substr(1)),c.qqPath=e,n.push(c),b.success()},function(c){j.callbacks.dropLog("Problem parsing '"+a.fullPath+"'.  FileError code "+c.code+".","error"),b.failure()}):a.isDirectory&&d(a).then(function(a){var d=a.length;qq.each(a,function(a,e){c(e).done(function(){d-=1,0===d&&b.success()})}),a.length||b.success()},function(c){j.callbacks.dropLog("Problem parsing '"+a.fullPath+"'.  FileError code "+c.code+".","error"),b.failure()}),b}function d(a,b,c,e){var f=e||new qq.Promise,g=b||a.createReader();return g.readEntries(function(b){var e=c?c.concat(b):b;b.length?setTimeout(function(){d(a,g,e,f)},0):f.success(e)},f.failure),f}function e(a,b){var d=[],e=new qq.Promise;return j.callbacks.processingDroppedFiles(),b.dropDisabled(!0),a.files.length>1&&!j.allowMultipleItems?(j.callbacks.processingDroppedFilesComplete([]),j.callbacks.dropError("tooManyFilesError",""),b.dropDisabled(!1),e.failure()):(n=[],qq.isFolderDropSupported(a)?qq.each(a.items,function(a,b){var f=b.webkitGetAsEntry();f&&(f.isFile?n.push(b.getAsFile()):d.push(c(f).done(function(){d.pop(),0===d.length&&e.success()})))}):n=a.files,0===d.length&&e.success()),e}function f(a){var c=new qq.UploadDropZone({HIDE_ZONES_EVENT_NAME:k,element:a,onEnter:function(b){qq(a).addClass(j.classes.dropActive),b.stopPropagation()},onLeaveNotDescendants:function(){qq(a).removeClass(j.classes.dropActive)},onDrop:function(a){e(a.dataTransfer,c).then(function(){b(n,c)},function(){j.callbacks.dropLog("Drop event DataTransfer parsing failed.  No files will be uploaded.","error")})}});return o.addDisposer(function(){c.dispose()}),qq(a).hasAttribute(l)&&qq(a).hide(),m.push(c),c}function g(a){var b;return qq.each(a.dataTransfer.types,function(a,c){return"Files"===c?(b=!0,!1):void 0}),b}function h(a){return qq.firefox()?!a.relatedTarget:qq.safari()?a.x<0||a.y<0:0===a.x&&0===a.y}function i(){var a=j.dropZoneElements,b=function(){setTimeout(function(){qq.each(a,function(a,b){qq(b).hasAttribute(l)&&qq(b).hide(),qq(b).removeClass(j.classes.dropActive)})},10)};qq.each(a,function(b,c){var d=f(c);a.length&&qq.supportedFeatures.fileDrop&&o.attach(document,"dragenter",function(b){!d.dropDisabled()&&g(b)&&qq.each(a,function(a,b){b instanceof HTMLElement&&qq(b).hasAttribute(l)&&qq(b).css({display:"block"})})})}),o.attach(document,"dragleave",function(a){h(a)&&b()}),o.attach(qq(document).children()[0],"mouseenter",function(){b()}),o.attach(document,"drop",function(a){a.preventDefault(),b()}),o.attach(document,k,b)}var j,k="qq-hidezones",l="qq-hide-dropzone",m=[],n=[],o=new qq.DisposeSupport;j={dropZoneElements:[],allowMultipleItems:!0,classes:{dropActive:null},callbacks:new qq.DragAndDrop.callbacks},qq.extend(j,a,!0),i(),qq.extend(this,{setupExtraDropzone:function(a){j.dropZoneElements.push(a),f(a)},removeDropzone:function(a){var b,c=j.dropZoneElements;for(b in c)if(c[b]===a)return c.splice(b,1)},dispose:function(){o.dispose(),qq.each(m,function(a,b){b.dispose()})}})},qq.DragAndDrop.callbacks=function(){"use strict";return{processingDroppedFiles:function(){},processingDroppedFilesComplete:function(){},dropError:function(a,b){qq.log("Drag & drop error code '"+a+" with these specifics: '"+b+"'","error")},dropLog:function(a,b){qq.log(a,b)}}},qq.UploadDropZone=function(a){"use strict";function b(){return qq.safari()||qq.firefox()&&qq.windows()}function c(){k||(b?l.attach(document,"dragover",function(a){a.preventDefault()}):l.attach(document,"dragover",function(a){a.dataTransfer&&(a.dataTransfer.dropEffect="none",a.preventDefault())}),k=!0)}function d(a){if(!qq.supportedFeatures.fileDrop)return!1;var b,c=a.dataTransfer,d=qq.safari();return b=qq.ie()&&qq.supportedFeatures.fileDrop?!0:"none"!==c.effectAllowed,c&&b&&(c.files||!d&&c.types.contains&&c.types.contains("Files"))}function e(a){return void 0!==a&&(j=a),j}function f(){function a(){b=document.createEvent("Event"),b.initEvent(h.HIDE_ZONES_EVENT_NAME,!0,!0)}var b;if(window.CustomEvent)try{b=new CustomEvent(h.HIDE_ZONES_EVENT_NAME)}catch(c){a()}else a();document.dispatchEvent(b)}function g(){l.attach(i,"dragover",function(a){if(d(a)){var b=qq.ie()&&qq.supportedFeatures.fileDrop?null:a.dataTransfer.effectAllowed;a.dataTransfer.dropEffect="move"===b||"linkMove"===b?"move":"copy",a.stopPropagation(),a.preventDefault()}}),l.attach(i,"dragenter",function(a){if(!e()){if(!d(a))return;h.onEnter(a)}}),l.attach(i,"dragleave",function(a){if(d(a)){h.onLeave(a);var b=document.elementFromPoint(a.clientX,a.clientY);qq(this).contains(b)||h.onLeaveNotDescendants(a)}}),l.attach(i,"drop",function(a){if(!e()){if(!d(a))return;a.preventDefault(),a.stopPropagation(),h.onDrop(a),f()}})}var h,i,j,k,l=new qq.DisposeSupport;h={element:null,onEnter:function(){},onLeave:function(){},onLeaveNotDescendants:function(){},onDrop:function(){}},qq.extend(h,a),i=h.element,c(),g(),qq.extend(this,{dropDisabled:function(a){return e(a)},dispose:function(){l.dispose()},getElement:function(){return i}})},qq.DeleteFileAjaxRequester=function(a){"use strict";function b(){return"POST"===d.method.toUpperCase()?{_method:"DELETE"}:{}}var c,d={method:"DELETE",uuidParamName:"qquuid",endpointStore:{},maxConnections:3,customHeaders:function(){return{}},paramsStore:{},cors:{expected:!1,sendCredentials:!1},log:function(){},onDelete:function(){},onDeleteComplete:function(){}};qq.extend(d,a),c=qq.extend(this,new qq.AjaxRequester({acceptHeader:"application/json",validMethods:["POST","DELETE"],method:d.method,endpointStore:d.endpointStore,paramsStore:d.paramsStore,mandatedParams:b(),maxConnections:d.maxConnections,customHeaders:function(a){return d.customHeaders.get(a)},log:d.log,onSend:d.onDelete,onComplete:d.onDeleteComplete,cors:d.cors})),qq.extend(this,{sendDelete:function(a,b,e){var f=e||{};d.log("Submitting delete file request for "+a),"DELETE"===d.method?c.initTransport(a).withPath(b).withParams(f).send():(f[d.uuidParamName]=b,c.initTransport(a).withParams(f).send())}})},function(){function a(a){var b,c=a.naturalWidth,d=a.naturalHeight,e=document.createElement("canvas");return c*d>1048576?(e.width=e.height=1,b=e.getContext("2d"),b.drawImage(a,-c+1,0),0===b.getImageData(0,0,1,1).data[3]):!1}function b(a,b,c){var d,e,f,g,h=document.createElement("canvas"),i=0,j=c,k=c;for(h.width=1,h.height=c,d=h.getContext("2d"),d.drawImage(a,0,0),e=d.getImageData(0,0,1,c).data;k>i;)f=e[4*(k-1)+3],0===f?j=k:i=k,k=j+i>>1;return g=k/c,0===g?1:g}function c(a,b,c){var d=document.createElement("canvas"),f=b.mime||"image/jpeg";return e(a,d,b,c),d.toDataURL(f,b.quality||.8)}function d(a){var b=5241e3;if(!qq.ios())throw new qq.Error("Downsampled dimensions can only be reliably calculated for iOS!");return a.origHeight*a.origWidth>b?{newHeight:Math.round(Math.sqrt(b*(a.origHeight/a.origWidth))),newWidth:Math.round(Math.sqrt(b*(a.origWidth/a.origHeight)))}:void 0}function e(c,e,g,h){var i,j=c.naturalWidth,k=c.naturalHeight,l=g.width,m=g.height,n=e.getContext("2d");n.save(),qq.supportedFeatures.unlimitedScaledImageSize||(i=d({origWidth:l,origHeight:m}),i&&(qq.log(qq.format("Had to reduce dimensions due to device limitations from {}w / {}h to {}w / {}h",l,m,i.newWidth,i.newHeight),"warn"),l=i.newWidth,m=i.newHeight)),f(e,l,m,g.orientation),qq.ios()?function(){a(c)&&(j/=2,k/=2);var d,e,f,g=1024,i=document.createElement("canvas"),o=h?b(c,j,k):1,p=Math.ceil(g*l/j),q=Math.ceil(g*m/k/o),r=0,s=0;for(i.width=i.height=g,d=i.getContext("2d");k>r;){for(e=0,f=0;j>e;)d.clearRect(0,0,g,g),d.drawImage(c,-e,-r),n.drawImage(i,0,0,g,g,f,s,p,q),e+=g,f+=p;r+=g,s+=q}n.restore(),i=d=null}():n.drawImage(c,0,0,l,m),e.qqImageRendered&&e.qqImageRendered()}function f(a,b,c,d){switch(d){case 5:case 6:case 7:case 8:a.width=c,a.height=b;break;default:a.width=b,a.height=c}var e=a.getContext("2d");switch(d){case 2:e.translate(b,0),e.scale(-1,1);break;case 3:e.translate(b,c),e.rotate(Math.PI);break;case 4:e.translate(0,c),e.scale(1,-1);break;case 5:e.rotate(.5*Math.PI),e.scale(1,-1);break;case 6:e.rotate(.5*Math.PI),e.translate(0,-c);break;case 7:e.rotate(.5*Math.PI),e.translate(b,-c),e.scale(-1,1);break;case 8:e.rotate(-.5*Math.PI),e.translate(-b,0)}}function g(a,b){var c=this;window.Blob&&a instanceof Blob&&function(){var b=new Image,d=window.URL&&window.URL.createObjectURL?window.URL:window.webkitURL&&window.webkitURL.createObjectURL?window.webkitURL:null;if(!d)throw Error("No createObjectURL function found to create blob url");b.src=d.createObjectURL(a),c.blob=a,a=b}(),a.naturalWidth||a.naturalHeight||(a.onload=function(){var a=c.imageLoadListeners;a&&(c.imageLoadListeners=null,setTimeout(function(){for(var b=0,c=a.length;c>b;b++)a[b]()},0))},a.onerror=b,this.imageLoadListeners=[]),this.srcImage=a}g.prototype.render=function(a,b){b=b||{};var d,f=this,g=this.srcImage.naturalWidth,h=this.srcImage.naturalHeight,i=b.width,j=b.height,k=b.maxWidth,l=b.maxHeight,m=!this.blob||"image/jpeg"===this.blob.type,n=a.tagName.toLowerCase();return this.imageLoadListeners?(this.imageLoadListeners.push(function(){f.render(a,b)}),void 0):(i&&!j?j=h*i/g<<0:j&&!i?i=g*j/h<<0:(i=g,j=h),k&&i>k&&(i=k,j=h*i/g<<0),l&&j>l&&(j=l,i=g*j/h<<0),d={width:i,height:j},qq.each(b,function(a,b){d[a]=b}),"img"===n?function(){var b=a.src;a.src=c(f.srcImage,d,m),b===a.src&&a.onload()}():"canvas"===n&&e(this.srcImage,a,d,m),"function"==typeof this.onrender&&this.onrender(a),void 0)},qq.MegaPixImage=g}(),qq.ImageGenerator=function(a){"use strict";function b(a){return"img"===a.tagName.toLowerCase()}function c(a){return"canvas"===a.tagName.toLowerCase()}function d(){return void 0!==(new Image).crossOrigin}function e(){var a=document.createElement("canvas");return a.getContext&&a.getContext("2d")}function f(a){var b=a.split("/"),c=b[b.length-1],d=qq.getExtension(c);switch(d=d&&d.toLowerCase()){case"jpeg":case"jpg":return"image/jpeg";case"png":return"image/png";case"bmp":return"image/bmp";case"gif":return"image/gif";case"tiff":case"tif":return"image/tiff"}}function g(a){var b,c,d,e=document.createElement("a");return e.href=a,b=e.protocol,d=e.port,c=e.hostname,b.toLowerCase()!==window.location.protocol.toLowerCase()?!0:c.toLowerCase()!==window.location.hostname.toLowerCase()?!0:d===window.location.port||qq.ie()?!1:!0}function h(b,c){b.onload=function(){b.onload=null,b.onerror=null,c.success(b)},b.onerror=function(){b.onload=null,b.onerror=null,a("Problem drawing thumbnail!","error"),c.failure(b,"Problem drawing thumbnail!")}}function i(a,b){a.qqImageRendered=function(){b.success(a)}}function j(d,e){var f=b(d)||c(d);return b(d)?h(d,e):c(d)?i(d,e):(e.failure(d),a(qq.format("Element container of type {} is not supported!",d.tagName),"error")),f}function k(b,c,d){var e=new qq.Promise,f=new qq.Identify(b,a),g=d.maxSize,h=null==d.orient?!0:d.orient,i=function(){c.onerror=null,c.onload=null,a("Could not render preview, file may be too large!","error"),e.failure(c,"Browser cannot render image!")};return f.isPreviewable().then(function(d){var f={parse:function(){return(new qq.Promise).success()}},k=h?new qq.Exif(b,a):f,l=new qq.MegaPixImage(b,i);j(c,e)&&k.parse().then(function(a){var b=a&&a.Orientation;l.render(c,{maxWidth:g,maxHeight:g,orientation:b,mime:d})},function(b){a(qq.format("EXIF data could not be parsed ({}).  Assuming orientation = 1.",b)),l.render(c,{maxWidth:g,maxHeight:g,mime:d})})},function(){a("Not previewable"),e.failure(c,"Not previewable")}),e}function l(a,b,c,d){var e=new Image,h=new qq.Promise;j(e,h),g(a)&&(e.crossOrigin="anonymous"),e.src=a,h.then(function(){j(b,c);var g=new qq.MegaPixImage(e);g.render(b,{maxWidth:d,maxHeight:d,mime:f(a)})},c.failure)}function m(a,b,c,d){j(b,c),qq(b).css({maxWidth:d+"px",maxHeight:d+"px"}),b.src=a}function n(a,f,h){var i=new qq.Promise,k=h.scale,n=k?h.maxSize:null;return k&&b(f)?e()?g(a)&&!d()?m(a,f,i,n):l(a,f,i,n):m(a,f,i,n):c(f)?l(a,f,i,n):j(f,i)&&(f.src=a),i}qq.extend(this,{generate:function(b,c,d){return qq.isString(b)?(a("Attempting to update thumbnail based on server response."),n(b,c,d||{})):(a("Attempting to draw client-side image preview."),k(b,c,d||{}))}})},qq.Exif=function(a,b){"use strict";function c(a){for(var b=0,c=0;a.length>0;)b+=parseInt(a.substring(0,2),16)*Math.pow(2,c),a=a.substring(2,a.length),c+=8;return b}function d(b,c){var e=b,f=c;return void 0===e&&(e=2,f=new qq.Promise),qq.readBlobToHex(a,e,4).then(function(a){var b,c=/^ffe([0-9])/.exec(a);c?"1"!==c[1]?(b=parseInt(a.slice(4,8),16),d(e+b+2,f)):f.success(e):f.failure("No EXIF header to be found!")}),f}function e(){var b=new qq.Promise;return qq.readBlobToHex(a,0,6).then(function(a){0!==a.indexOf("ffd8")?b.failure("Not a valid JPEG!"):d().then(function(a){b.success(a)},function(a){b.failure(a)})}),b}function f(b){var c=new qq.Promise;return qq.readBlobToHex(a,b+10,2).then(function(a){c.success("4949"===a)}),c}function g(b,d){var e=new qq.Promise;return qq.readBlobToHex(a,b+18,2).then(function(a){return d?e.success(c(a)):(e.success(parseInt(a,16)),void 0)}),e}function h(b,c){var d=b+20,e=12*c;return qq.readBlobToHex(a,d,e)}function i(a){for(var b=[],c=0;c+24<=a.length;)b.push(a.slice(c,c+24)),c+=24;return b}function j(a,b){var d=16,e=qq.extend([],k),f={};return qq.each(b,function(b,g){var h,i,j,k=g.slice(0,4),m=a?c(k):parseInt(k,16),n=e.indexOf(m);return n>=0&&(i=l[m].name,j=l[m].bytes,h=g.slice(d,d+2*j),f[i]=a?c(h):parseInt(h,16),e.splice(n,1)),0===e.length?!1:void 0}),f}var k=[274],l={274:{name:"Orientation",bytes:2}};qq.extend(this,{parse:function(){var c=new qq.Promise,d=function(a){b(qq.format("EXIF header parse failed: '{}' ",a)),c.failure(a)};return e().then(function(e){b(qq.format("Moving forward with EXIF header parsing for '{}'",void 0===a.name?"blob":a.name)),f(e).then(function(a){b(qq.format("EXIF Byte order is {} endian",a?"little":"big")),g(e,a).then(function(f){b(qq.format("Found {} APP1 directory entries",f)),h(e,f).then(function(d){var e=i(d),f=j(a,e);b("Successfully parsed some EXIF tags"),c.success(f)},d)},d)},d)},d),c}})},qq.Identify=function(a,b){"use strict";function c(a,b){var c=!1,d=[].concat(a);return qq.each(d,function(a,d){return 0===b.indexOf(d)?(c=!0,!1):void 0}),c}qq.extend(this,{isPreviewable:function(){var d=this,e=new qq.Promise,f=!1,g=void 0===a.name?"blob":a.name;return b(qq.format("Attempting to determine if {} can be rendered in this browser",g)),b("First pass: check type attribute of blob object."),this.isPreviewableSync()?(b("Second pass: check for magic bytes in file header."),qq.readBlobToHex(a,0,4).then(function(a){qq.each(d.PREVIEWABLE_MIME_TYPES,function(b,d){return c(d,a)?(("image/tiff"!==b||qq.supportedFeatures.tiffPreviews)&&(f=!0,e.success(b)),!1):void 0}),b(qq.format("'{}' is {} able to be rendered in this browser",g,f?"":"NOT")),f||e.failure()},function(){b("Error reading file w/ name '"+g+"'.  Not able to be rendered in this browser."),e.failure()})):e.failure(),e},isPreviewableSync:function(){var c=a.type,d=qq.indexOf(Object.keys(this.PREVIEWABLE_MIME_TYPES),c)>=0,e=!1,f=void 0===a.name?"blob":a.name;return d&&(e="image/tiff"===c?qq.supportedFeatures.tiffPreviews:!0),!e&&b(f+" is not previewable in this browser per the blob's type attr"),e}})},qq.Identify.prototype.PREVIEWABLE_MIME_TYPES={"image/jpeg":"ffd8ff","image/gif":"474946","image/png":"89504e","image/bmp":"424d","image/tiff":["49492a00","4d4d002a"]},qq.ImageValidation=function(a,b){"use strict";function c(a){var b=!1;return qq.each(a,function(a,c){return c>0?(b=!0,!1):void 0}),b}function d(){var c=new qq.Promise;return new qq.Identify(a,b).isPreviewable().then(function(){var d=new Image,e=window.URL&&window.URL.createObjectURL?window.URL:window.webkitURL&&window.webkitURL.createObjectURL?window.webkitURL:null;e?(d.onerror=function(){b("Cannot determine dimensions for image.  May be too large.","error"),c.failure()},d.onload=function(){c.success({width:this.width,height:this.height})},d.src=e.createObjectURL(a)):(b("No createObjectURL function available to generate image URL!","error"),c.failure())},c.failure),c}function e(a,b){var c;return qq.each(a,function(a,d){if(d>0){var e=/(max|min)(Width|Height)/.exec(a),f=e[2].charAt(0).toLowerCase()+e[2].slice(1),g=b[f];switch(e[1]){case"min":if(d>g)return c=a,!1;break;case"max":if(g>d)return c=a,!1}}}),c}this.validate=function(a){var f=new qq.Promise;return b("Attempting to validate image."),c(a)?d().then(function(b){var c=e(a,b);c?f.failure(c):f.success()},f.success):f.success(),f}},qq.Session=function(a){"use strict";function b(a){return qq.isArray(a)?!0:(d.log("Session response is not an array.","error"),void 0)}function c(a,c,e,f){var g=!1;c=c&&b(a),c&&qq.each(a,function(a,b){if(null==b.uuid)g=!0,d.log(qq.format("Session response item {} did not include a valid UUID - ignoring.",a),"error");else if(null==b.name)g=!0,d.log(qq.format("Session response item {} did not include a valid name - ignoring.",a),"error");else try{return d.addFileRecord(b),!0}catch(c){g=!0,d.log(c.message,"error")}return!1}),f[c&&!g?"success":"failure"](a,e)}var d={endpoint:null,params:{},customHeaders:{},cors:{},addFileRecord:function(){},log:function(){}};qq.extend(d,a,!0),this.refresh=function(){var a=new qq.Promise,b=function(b,d,e){c(b,d,e,a)},e=qq.extend({},d),f=new qq.SessionAjaxRequester(qq.extend(e,{onComplete:b}));return f.queryServer(),a}},qq.SessionAjaxRequester=function(a){"use strict";function b(a,b,c){var e=null;if(null!=b.responseText)try{e=qq.parseJson(b.responseText)}catch(f){d.log("Problem parsing session response: "+f.message,"error"),c=!0}d.onComplete(e,!c,b)}var c,d={endpoint:null,customHeaders:{},params:{},cors:{expected:!1,sendCredentials:!1},onComplete:function(){},log:function(){}};qq.extend(d,a),c=qq.extend(this,new qq.AjaxRequester({acceptHeader:"application/json",validMethods:["GET"],method:"GET",endpointStore:{get:function(){return d.endpoint}},customHeaders:d.customHeaders,log:d.log,onComplete:b,cors:d.cors})),qq.extend(this,{queryServer:function(){var a=qq.extend({},d.params);d.log("Session query request."),c.initTransport("sessionRefresh").withParams(a).withCacheBuster().send()}})},qq.FormSupport=function(a,b,c){"use strict";function d(a){a.getAttribute("action")&&(h.newEndpoint=a.getAttribute("action"))}function e(a,b){return!a.checkValidity||a.checkValidity()?!0:(c("Form did not pass validation checks - will not upload.","error"),b(),void 0)}function f(a){var c=a.submit;qq(a).attach("submit",function(d){d=d||window.event,d.preventDefault?d.preventDefault():d.returnValue=!1,e(a,c)&&b()}),a.submit=function(){e(a,c)&&b()}}function g(a){return a&&(qq.isString(a)&&(a=document.getElementById(a)),a&&(c("Attaching to form element."),d(a),i&&f(a))),a}var h=this,i=a.interceptSubmit,j=a.element,k=a.autoUpload;qq.extend(this,{newEndpoint:null,newAutoUpload:k,attachedToForm:!1,getFormInputsAsObject:function(){return null==j?null:h._form2Obj(j)}}),j=g(j),this.attachedToForm=!!j},qq.extend(qq.FormSupport.prototype,{_form2Obj:function(a){"use strict";var b={},c=function(a){var b=["button","image","reset","submit"];return qq.indexOf(b,a.toLowerCase())<0},d=function(a){return qq.indexOf(["checkbox","radio"],a.toLowerCase())>=0},e=function(a){return d(a.type)&&!a.checked?!0:a.disabled&&"hidden"!==a.type.toLowerCase()},f=function(a){var b=null;return qq.each(qq(a).children(),function(a,c){return"option"===c.tagName.toLowerCase()&&c.selected?(b=c.value,!1):void 0}),b};return qq.each(a.elements,function(a,d){if(!qq.isInput(d,!0)&&"textarea"!==d.tagName.toLowerCase()||!c(d.type)||e(d)){if("select"===d.tagName.toLowerCase()&&!e(d)){var g=f(d);null!==g&&(b[d.name]=g)}}else b[d.name]=d.value}),b}}),qq.Scaler=function(a,b){"use strict";var c=a.sendOriginal,d=a.orient,e=a.defaultType,f=a.defaultQuality/100,g=a.failureText,h=a.includeExif,i=this._getSortedSizes(a.sizes);qq.extend(this,{enabled:qq.supportedFeatures.scaling&&i.length>0,getFileRecords:function(a,j,k){var l=this,m=[],n=k.blob?k.blob:k,o=new qq.Identify(n,b);return o.isPreviewableSync()?(qq.each(i,function(a,c){var i=l._determineOutputType({defaultType:e,requestedType:c.type,refType:n.type});m.push({uuid:qq.getUniqueId(),name:l._getName(j,{name:c.name,type:i,refType:n.type}),blob:new qq.BlobProxy(n,qq.bind(l._generateScaledImage,l,{maxSize:c.maxSize,orient:d,type:i,quality:f,failedText:g,includeExif:h,log:b}))})}),c&&m.push({uuid:a,name:j,blob:n})):m.push({uuid:a,name:j,blob:n}),m},handleNewFile:function(a,b,c,d,e,f,g,h){var i=this,j=(a.qqButtonId||a.blob&&a.blob.qqButtonId,[]),k=null,l=h.addFileToHandler,m=h.uploadData,n=h.paramsStore,o=qq.getUniqueId();qq.each(i.getFileRecords(c,b,a),function(b,c){var g,h=a,i=d;c.blob instanceof qq.BlobProxy&&(h=c.blob,i=-1),g=m.addFile({uuid:c.uuid,name:c.name,size:i,batchId:f,proxyGroupId:o}),c.blob instanceof qq.BlobProxy?j.push(g):k=g,l(g,h),e.push({id:g,file:h})}),null!==k&&(qq.each(j,function(a,b){var c={qqparentuuid:m.retrieve({id:k}).uuid,qqparentsize:m.retrieve({id:k}).size};c[g]=m.retrieve({id:b}).uuid,m.setParentId(b,k),n.addReadOnly(b,c)}),j.length&&function(){var a={};a[g]=m.retrieve({id:k}).uuid,n.addReadOnly(k,a)}())}})},qq.extend(qq.Scaler.prototype,{scaleImage:function(a,b,c){"use strict";if(!qq.supportedFeatures.scaling)throw new qq.Error("Scaling is not supported in this browser!");var d=new qq.Promise,e=c.log,f=c.getFile(a),g=c.uploadData.retrieve({id:a}),h=g&&g.name,i=g&&g.uuid,j={sendOriginal:!1,orient:b.orient,defaultType:b.type||null,defaultQuality:b.quality,failedToScaleText:"Unable to scale",sizes:[{name:"",maxSize:b.maxSize}]},k=new qq.Scaler(j,e);return qq.Scaler&&qq.supportedFeatures.imagePreviews&&f?qq.bind(function(){var b=k.getFileRecords(i,h,f)[0];b&&b.blob instanceof qq.BlobProxy?b.blob.create().then(d.success,d.failure):(e(a+" is not a scalable image!","error"),d.failure())},this)():(d.failure(),e("Could not generate requested scaled image for "+a+".  "+"Scaling is either not possible in this browser, or the file could not be located.","error")),d},_determineOutputType:function(a){"use strict";var b=a.requestedType,c=a.defaultType,d=a.refType;return c||b?b?qq.indexOf(Object.keys(qq.Identify.prototype.PREVIEWABLE_MIME_TYPES),b)>=0?"image/tiff"===b?qq.supportedFeatures.tiffPreviews?b:c:b:c:c:"image/jpeg"!==d?"image/png":d},_getName:function(a,b){"use strict";var c=a.lastIndexOf("."),d=b.type||"image/png",e=b.refType,f="",g=qq.getExtension(a),h="";return b.name&&b.name.trim().length&&(h=" ("+b.name+")"),c>=0?(f=a.substr(0,c),e!==d&&(g=d.split("/")[1]),f+=h+"."+g):f=a+h,f},_getSortedSizes:function(a){"use strict";return a=qq.extend([],a),a.sort(function(a,b){return a.maxSize>b.maxSize?1:a.maxSize<b.maxSize?-1:0})},_generateScaledImage:function(a,b){"use strict";var c=this,d=a.log,e=a.maxSize,f=a.orient,g=a.type,h=a.quality,i=a.failedText,j=a.includeExif&&"image/jpeg"===b.type&&"image/jpeg"===g,k=new qq.Promise,l=new qq.ImageGenerator(d),m=document.createElement("canvas");return d("Attempting to generate scaled version for "+b.name),l.generate(b,m,{maxSize:e,orient:f}).then(function(){var a=m.toDataURL(g,h),e=function(){d("Success generating scaled version for "+b.name);var c=qq.dataUriToBlob(a);k.success(c)};j?c._insertExifHeader(b,a,d).then(function(b){a=b,e()},function(){d("Problem inserting EXIF header into scaled image.  Using scaled image w/out EXIF data.","error"),e()}):e()},function(){d("Failed attempt to generate scaled version for "+b.name,"error"),k.failure(i)}),k},_insertExifHeader:function(a,b,c){"use strict";var d=new FileReader,e=new qq.Promise,f="";return d.onload=function(){f=d.result,e.success(ExifRestorer.restore(f,b))},d.onerror=function(){c("Problem reading "+a.name+" during attempt to transfer EXIF data to scaled version.","error"),e.failure()},d.readAsDataURL(a),e},_dataUriToBlob:function(a){"use strict";var b,c,d,e;return b=a.split(",")[0].indexOf("base64")>=0?atob(a.split(",")[1]):decodeURI(a.split(",")[1]),c=a.split(",")[0].split(":")[1].split(";")[0],d=new ArrayBuffer(b.length),e=new Uint8Array(d),qq.each(b,function(a,b){e[a]=b.charCodeAt(0)}),this._createBlob(d,c)},_createBlob:function(a,b){"use strict";var c=window.BlobBuilder||window.WebKitBlobBuilder||window.MozBlobBuilder||window.MSBlobBuilder,d=c&&new c;return d?(d.append(a),d.getBlob(b)):new Blob([a],{type:b})}});var ExifRestorer=function(){var a={};return a.KEY_STR="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",a.encode64=function(a){var b,c,d,e,f,g="",h="",i="",j=0;do b=a[j++],c=a[j++],h=a[j++],d=b>>2,e=(3&b)<<4|c>>4,f=(15&c)<<2|h>>6,i=63&h,isNaN(c)?f=i=64:isNaN(h)&&(i=64),g=g+this.KEY_STR.charAt(d)+this.KEY_STR.charAt(e)+this.KEY_STR.charAt(f)+this.KEY_STR.charAt(i),b=c=h="",d=e=f=i="";while(j<a.length);return g},a.restore=function(a,b){var c="data:image/jpeg;base64,";if(!a.match(c))return b;var d=this.decode64(a.replace(c,"")),e=this.slice2Segments(d),f=this.exifManipulation(b,e);return c+this.encode64(f)},a.exifManipulation=function(a,b){var c=this.getExifArray(b),d=this.insertExif(a,c),e=new Uint8Array(d);return e},a.getExifArray=function(a){for(var b,c=0;c<a.length;c++)if(b=a[c],255==b[0]&225==b[1])return b;return[]},a.insertExif=function(a,b){var c=a.replace("data:image/jpeg;base64,",""),d=this.decode64(c),e=d.indexOf(255,3),f=d.slice(0,e),g=d.slice(e),h=f;return h=h.concat(b),h=h.concat(g)},a.slice2Segments=function(a){for(var b=0,c=[];;){if(255==a[b]&218==a[b+1])break;if(255==a[b]&216==a[b+1])b+=2;else{var d=256*a[b+2]+a[b+3],e=b+d+2,f=a.slice(b,e);c.push(f),b=e}if(b>a.length)break}return c},a.decode64=function(a){var b,c,d,e,f,g="",h="",i=0,j=[],k=/[^A-Za-z0-9\+\/\=]/g;if(k.exec(a))throw new Error("There were invalid base64 characters in the input text.  Valid base64 characters are A-Z, a-z, 0-9, '+', '/',and '='");a=a.replace(/[^A-Za-z0-9\+\/\=]/g,"");do d=this.KEY_STR.indexOf(a.charAt(i++)),e=this.KEY_STR.indexOf(a.charAt(i++)),f=this.KEY_STR.indexOf(a.charAt(i++)),h=this.KEY_STR.indexOf(a.charAt(i++)),b=d<<2|e>>4,c=(15&e)<<4|f>>2,g=(3&f)<<6|h,j.push(b),64!=f&&j.push(c),64!=h&&j.push(g),b=c=g="",d=e=f=h="";while(i<a.length);return j},a}();qq.TotalProgress=function(a,b){"use strict";var c={},d=0,e=0,f=-1,g=-1,h=function(b,c){(b!==f||c!==g)&&a(b,c),f=b,g=c},i=function(a,b){var c=!0;return qq.each(a,function(a,d){return qq.indexOf(b,d)>=0?(c=!1,!1):void 0}),c},j=function(a){m(a,-1,-1),delete c[a]},k=function(a,b,c){(0===b.length||i(b,c))&&(h(e,e),this.reset())},l=function(a){var d=b(a);d>0&&(m(a,0,d),c[a]={loaded:0,total:d})},m=function(a,b,f){var g=c[a]?c[a].loaded:0,i=c[a]?c[a].total:0;-1===b&&-1===f?(d-=g,e-=i):(b&&(d+=b-g),f&&(e+=f-i)),h(d,e)};qq.extend(this,{onAllComplete:k,onStatusChange:function(a,b,c){c===qq.status.CANCELED||c===qq.status.REJECTED?j(a):c===qq.status.SUBMITTING&&l(a)},onIndividualProgress:function(a,b,d){m(a,b,d),c[a]={loaded:b,total:d}},onNewSize:function(a){l(a)},reset:function(){c={},d=0,e=0}})},qq.UiEventHandler=function(a,b){"use strict";function c(a){d.attach(a,e.eventType,function(a){a=a||window.event;var b=a.target||a.srcElement;e.onHandled(b,a)})}var d=new qq.DisposeSupport,e={eventType:"click",attachTo:null,onHandled:function(){}};qq.extend(this,{addHandler:function(a){c(a)},dispose:function(){d.dispose()}}),qq.extend(b,{getFileIdFromItem:function(a){return a.qqFileId},getDisposeSupport:function(){return d}}),qq.extend(e,a),e.attachTo&&c(e.attachTo)},qq.FileButtonsClickHandler=function(a){"use strict";function b(a,b){qq.each(e,function(c,e){var f,g=c.charAt(0).toUpperCase()+c.slice(1);return d.templating["is"+g](a)?(f=d.templating.getFileId(a),qq.preventDefault(b),d.log(qq.format("Detected valid file button click event on file '{}', ID: {}.",d.onGetName(f),f)),e(f),!1):void 0})}var c={},d={templating:null,log:function(){},onDeleteFile:function(){},onCancel:function(){},onRetry:function(){},onPause:function(){},onContinue:function(){},onGetName:function(){}},e={cancel:function(a){d.onCancel(a)},retry:function(a){d.onRetry(a)},deleteButton:function(a){d.onDeleteFile(a)},pause:function(a){d.onPause(a)},continueButton:function(a){d.onContinue(a)}};qq.extend(d,a),d.eventType="click",d.onHandled=b,d.attachTo=d.templating.getFileList(),qq.extend(this,new qq.UiEventHandler(d,c))},qq.FilenameClickHandler=function(a){"use strict";function b(a,b){if(d.templating.isFileName(a)||d.templating.isEditIcon(a)){var e=d.templating.getFileId(a),f=d.onGetUploadStatus(e);f===qq.status.SUBMITTED&&(d.log(qq.format("Detected valid filename click event on file '{}', ID: {}.",d.onGetName(e),e)),qq.preventDefault(b),c.handleFilenameEdit(e,a,!0))}}var c={},d={templating:null,log:function(){},classes:{file:"qq-upload-file",editNameIcon:"qq-edit-filename-icon"},onGetUploadStatus:function(){},onGetName:function(){}};qq.extend(d,a),d.eventType="click",d.onHandled=b,qq.extend(this,new qq.FilenameEditHandler(d,c))
+},qq.FilenameInputFocusInHandler=function(a,b){"use strict";function c(a){if(d.templating.isEditInput(a)){var c=d.templating.getFileId(a),e=d.onGetUploadStatus(c);e===qq.status.SUBMITTED&&(d.log(qq.format("Detected valid filename input focus event on file '{}', ID: {}.",d.onGetName(c),c)),b.handleFilenameEdit(c,a))}}var d={templating:null,onGetUploadStatus:function(){},log:function(){}};b||(b={}),d.eventType="focusin",d.onHandled=c,qq.extend(d,a),qq.extend(this,new qq.FilenameEditHandler(d,b))},qq.FilenameInputFocusHandler=function(a){"use strict";a.eventType="focus",a.attachTo=null,qq.extend(this,new qq.FilenameInputFocusInHandler(a,{}))},qq.FilenameEditHandler=function(a,b){"use strict";function c(a){var b=h.onGetName(a),c=b.lastIndexOf(".");return c>0&&(b=b.substr(0,c)),b}function d(a){var b=h.onGetName(a);return qq.getExtension(b)}function e(a,b){var c,e=a.value;void 0!==e&&qq.trimStr(e).length>0&&(c=d(b),void 0!==c&&(e=e+"."+c),h.onSetName(b,e)),h.onEditingStatusChange(b,!1)}function f(a,c){b.getDisposeSupport().attach(a,"blur",function(){e(a,c)})}function g(a,c){b.getDisposeSupport().attach(a,"keyup",function(b){var d=b.keyCode||b.which;13===d&&e(a,c)})}var h={templating:null,log:function(){},onGetUploadStatus:function(){},onGetName:function(){},onSetName:function(){},onEditingStatusChange:function(){}};qq.extend(h,a),h.attachTo=h.templating.getFileList(),qq.extend(this,new qq.UiEventHandler(h,b)),qq.extend(b,{handleFilenameEdit:function(a,b,d){var e=h.templating.getEditInput(a);h.onEditingStatusChange(a,!0),e.value=c(a),d&&e.focus(),f(e,a),g(e,a)}})};var CryptoJS=CryptoJS||function(a,b){var c={},d=c.lib={},e=d.Base=function(){function a(){}return{extend:function(b){a.prototype=this;var c=new a;return b&&c.mixIn(b),c.hasOwnProperty("init")||(c.init=function(){c.$super.init.apply(this,arguments)}),c.init.prototype=c,c.$super=this,c},create:function(){var a=this.extend();return a.init.apply(a,arguments),a},init:function(){},mixIn:function(a){for(var b in a)a.hasOwnProperty(b)&&(this[b]=a[b]);a.hasOwnProperty("toString")&&(this.toString=a.toString)},clone:function(){return this.init.prototype.extend(this)}}}(),f=d.WordArray=e.extend({init:function(a,c){a=this.words=a||[],this.sigBytes=c!=b?c:4*a.length},toString:function(a){return(a||h).stringify(this)},concat:function(a){var b=this.words,c=a.words,d=this.sigBytes,e=a.sigBytes;if(this.clamp(),d%4)for(var f=0;e>f;f++){var g=255&c[f>>>2]>>>24-8*(f%4);b[d+f>>>2]|=g<<24-8*((d+f)%4)}else if(c.length>65535)for(var f=0;e>f;f+=4)b[d+f>>>2]=c[f>>>2];else b.push.apply(b,c);return this.sigBytes+=e,this},clamp:function(){var b=this.words,c=this.sigBytes;b[c>>>2]&=4294967295<<32-8*(c%4),b.length=a.ceil(c/4)},clone:function(){var a=e.clone.call(this);return a.words=this.words.slice(0),a},random:function(b){for(var c=[],d=0;b>d;d+=4)c.push(0|4294967296*a.random());return new f.init(c,b)}}),g=c.enc={},h=g.Hex={stringify:function(a){for(var b=a.words,c=a.sigBytes,d=[],e=0;c>e;e++){var f=255&b[e>>>2]>>>24-8*(e%4);d.push((f>>>4).toString(16)),d.push((15&f).toString(16))}return d.join("")},parse:function(a){for(var b=a.length,c=[],d=0;b>d;d+=2)c[d>>>3]|=parseInt(a.substr(d,2),16)<<24-4*(d%8);return new f.init(c,b/2)}},i=g.Latin1={stringify:function(a){for(var b=a.words,c=a.sigBytes,d=[],e=0;c>e;e++){var f=255&b[e>>>2]>>>24-8*(e%4);d.push(String.fromCharCode(f))}return d.join("")},parse:function(a){for(var b=a.length,c=[],d=0;b>d;d++)c[d>>>2]|=(255&a.charCodeAt(d))<<24-8*(d%4);return new f.init(c,b)}},j=g.Utf8={stringify:function(a){try{return decodeURIComponent(escape(i.stringify(a)))}catch(b){throw new Error("Malformed UTF-8 data")}},parse:function(a){return i.parse(unescape(encodeURIComponent(a)))}},k=d.BufferedBlockAlgorithm=e.extend({reset:function(){this._data=new f.init,this._nDataBytes=0},_append:function(a){"string"==typeof a&&(a=j.parse(a)),this._data.concat(a),this._nDataBytes+=a.sigBytes},_process:function(b){var c=this._data,d=c.words,e=c.sigBytes,g=this.blockSize,h=4*g,i=e/h;i=b?a.ceil(i):a.max((0|i)-this._minBufferSize,0);var j=i*g,k=a.min(4*j,e);if(j){for(var l=0;j>l;l+=g)this._doProcessBlock(d,l);var m=d.splice(0,j);c.sigBytes-=k}return new f.init(m,k)},clone:function(){var a=e.clone.call(this);return a._data=this._data.clone(),a},_minBufferSize:0});d.Hasher=k.extend({cfg:e.extend(),init:function(a){this.cfg=this.cfg.extend(a),this.reset()},reset:function(){k.reset.call(this),this._doReset()},update:function(a){return this._append(a),this._process(),this},finalize:function(a){a&&this._append(a);var b=this._doFinalize();return b},blockSize:16,_createHelper:function(a){return function(b,c){return new a.init(c).finalize(b)}},_createHmacHelper:function(a){return function(b,c){return new l.HMAC.init(a,c).finalize(b)}}});var l=c.algo={};return c}(Math);!function(){var a=CryptoJS,b=a.lib,c=b.WordArray,d=a.enc;d.Base64={stringify:function(a){var b=a.words,c=a.sigBytes,d=this._map;a.clamp();for(var e=[],f=0;c>f;f+=3)for(var g=255&b[f>>>2]>>>24-8*(f%4),h=255&b[f+1>>>2]>>>24-8*((f+1)%4),i=255&b[f+2>>>2]>>>24-8*((f+2)%4),j=g<<16|h<<8|i,k=0;4>k&&c>f+.75*k;k++)e.push(d.charAt(63&j>>>6*(3-k)));var l=d.charAt(64);if(l)for(;e.length%4;)e.push(l);return e.join("")},parse:function(a){var b=a.length,d=this._map,e=d.charAt(64);if(e){var f=a.indexOf(e);-1!=f&&(b=f)}for(var g=[],h=0,i=0;b>i;i++)if(i%4){var j=d.indexOf(a.charAt(i-1))<<2*(i%4),k=d.indexOf(a.charAt(i))>>>6-2*(i%4);g[h>>>2]|=(j|k)<<24-8*(h%4),h++}return c.create(g,h)},_map:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="}}(),function(){var a=CryptoJS,b=a.lib,c=b.Base,d=a.enc,e=d.Utf8,f=a.algo;f.HMAC=c.extend({init:function(a,b){a=this._hasher=new a.init,"string"==typeof b&&(b=e.parse(b));var c=a.blockSize,d=4*c;b.sigBytes>d&&(b=a.finalize(b)),b.clamp();for(var f=this._oKey=b.clone(),g=this._iKey=b.clone(),h=f.words,i=g.words,j=0;c>j;j++)h[j]^=1549556828,i[j]^=909522486;f.sigBytes=g.sigBytes=d,this.reset()},reset:function(){var a=this._hasher;a.reset(),a.update(this._iKey)},update:function(a){return this._hasher.update(a),this},finalize:function(a){var b=this._hasher,c=b.finalize(a);b.reset();var d=b.finalize(this._oKey.clone().concat(c));return d}})}(),function(){var a=CryptoJS,b=a.lib,c=b.WordArray,d=b.Hasher,e=a.algo,f=[],g=e.SHA1=d.extend({_doReset:function(){this._hash=new c.init([1732584193,4023233417,2562383102,271733878,3285377520])},_doProcessBlock:function(a,b){for(var c=this._hash.words,d=c[0],e=c[1],g=c[2],h=c[3],i=c[4],j=0;80>j;j++){if(16>j)f[j]=0|a[b+j];else{var k=f[j-3]^f[j-8]^f[j-14]^f[j-16];f[j]=k<<1|k>>>31}var l=(d<<5|d>>>27)+i+f[j];l+=20>j?(e&g|~e&h)+1518500249:40>j?(e^g^h)+1859775393:60>j?(e&g|e&h|g&h)-1894007588:(e^g^h)-899497514,i=h,h=g,g=e<<30|e>>>2,e=d,d=l}c[0]=0|c[0]+d,c[1]=0|c[1]+e,c[2]=0|c[2]+g,c[3]=0|c[3]+h,c[4]=0|c[4]+i},_doFinalize:function(){var a=this._data,b=a.words,c=8*this._nDataBytes,d=8*a.sigBytes;return b[d>>>5]|=128<<24-d%32,b[(d+64>>>9<<4)+14]=Math.floor(c/4294967296),b[(d+64>>>9<<4)+15]=c,a.sigBytes=4*b.length,this._process(),this._hash},clone:function(){var a=d.clone.call(this);return a._hash=this._hash.clone(),a}});a.SHA1=d._createHelper(g),a.HmacSHA1=d._createHmacHelper(g)}();
+/*! 2015-06-09 */
diff --git a/node_modules/react-s3-fineuploader b/node_modules/react-s3-fineuploader
deleted file mode 160000
index e2890cf3..00000000
--- a/node_modules/react-s3-fineuploader
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e2890cf3d28d010abc04e0de3b218afe8c949596
diff --git a/sass/ascribe_uploader.scss b/sass/ascribe_uploader.scss
new file mode 100644
index 00000000..e6583313
--- /dev/null
+++ b/sass/ascribe_uploader.scss
@@ -0,0 +1,64 @@
+.file-drag-and-drop {
+    display: table-cell;
+    outline: 1px dashed #616161;
+    cursor: pointer;
+    vertical-align: middle;
+    text-align: center;
+    height:208px;
+    width: 672px;
+    background-color: #FAFAFA;
+    transition: .1s linear background-color;
+}
+
+.file-drag-and-drop:hover {
+    background-color: rgba(72, 218, 203, 0.2);
+}
+
+.file-drag-and-drop > span {
+    font-size: 1.5em;
+}
+
+.has-files {
+    text-align: left;
+    padding: 3em 0 0 0;
+}
+
+.file-drag-and-drop-position {
+    display: inline-block;
+    margin: 0 0 3em 3em;
+    float:left;
+}
+
+.file-drag-and-drop-preview-table-wrapper {
+    display: table;
+    height:94px;
+    width:104px;
+}
+
+.file-drag-and-drop-preview {
+    overflow:hidden;
+    cursor: default;
+    background-color: #EEEEEE;
+    border: 1px solid #616161;
+}
+
+.file-drag-and-drop-preview-image {
+    display: table;
+    height:104px;
+    width:104px;
+    overflow:hidden;
+    border: 1px solid #616161;
+}
+
+.file-drag-and-drop-preview-other {
+    display: table-cell;
+    text-align: center;
+    vertical-align: middle;
+
+}
+
+.file-drag-and-drop-preview-other span {
+    font-size: 1.1em;
+    display: block;
+    margin-top: -10px;
+}