Merge remote-tracking branch 'origin/div' into div

admin

2020-04-13 dd5b15229cb15459fa7c31ccea77dac28cbfafbd

 fanli/src/main/webapp/admin/new/js/third-party/webuploader/webuploader.withoutimage.js

@@ -1,4593 +1,4593 @@
/*! WebUploader 0.1.2 */


/**
 * @fileOverview 让内部各个部件的代码可以用[amd](https://github.com/amdjs/amdjs-api/wiki/AMD)模块定义方式组织起来。
 *
 * AMD API 内部的简单不完全实现，请忽略。只有当WebUploader被合并成一个文件的时候才会引入。
 */
(function( root, factory ) {
    var modules = {},

        // 内部require, 简单不完全实现。
        // https://github.com/amdjs/amdjs-api/wiki/require
        _require = function( deps, callback ) {
            var args, len, i;

            // 如果deps不是数组，则直接返回指定module
            if ( typeof deps === 'string' ) {
                return getModule( deps );
            } else {
                args = [];
                for( len = deps.length, i = 0; i < len; i++ ) {
                    args.push( getModule( deps[ i ] ) );
                }

                return callback.apply( null, args );
            }
        },

        // 内部define，暂时不支持不指定id.
        _define = function( id, deps, factory ) {
            if ( arguments.length === 2 ) {
                factory = deps;
                deps = null;
            }

            _require( deps || [], function() {
                setModule( id, factory, arguments );
            });
        },

        // 设置module, 兼容CommonJs写法。
        setModule = function( id, factory, args ) {
            var module = {
                    exports: factory
                },
                returned;

            if ( typeof factory === 'function' ) {
                args.length || (args = [ _require, module.exports, module ]);
                returned = factory.apply( null, args );
                returned !== undefined && (module.exports = returned);
            }

            modules[ id ] = module.exports;
        },

        // 根据id获取module
        getModule = function( id ) {
            var module = modules[ id ] || root[ id ];

            if ( !module ) {
                throw new Error( '`' + id + '` is undefined' );
            }

            return module;
        },

        // 将所有modules，将路径ids装换成对象。
        exportsTo = function( obj ) {
            var key, host, parts, part, last, ucFirst;

            // make the first character upper case.
            ucFirst = function( str ) {
                return str && (str.charAt( 0 ).toUpperCase() + str.substr( 1 ));
            };

            for ( key in modules ) {
                host = obj;

                if ( !modules.hasOwnProperty( key ) ) {
                    continue;
                }

                parts = key.split('/');
                last = ucFirst( parts.pop() );

                while( (part = ucFirst( parts.shift() )) ) {
                    host[ part ] = host[ part ] || {};
                    host = host[ part ];
                }

                host[ last ] = modules[ key ];
            }
        },

        exports = factory( root, _define, _require ),
        origin;

    // exports every module.
    exportsTo( exports );

    if ( typeof module === 'object' && typeof module.exports === 'object' ) {

        // For CommonJS and CommonJS-like environments where a proper window is present,
        module.exports = exports;
    } else if ( typeof define === 'function' && define.amd ) {

        // Allow using this built library as an AMD module
        // in another project. That other project will only
        // see this AMD call, not the internal modules in
        // the closure below.
        define([], exports );
    } else {

        // Browser globals case. Just assign the
        // result to a property on the global.
        origin = root.WebUploader;
        root.WebUploader = exports;
        root.WebUploader.noConflict = function() {
            root.WebUploader = origin;
        };
    }
})( this, function( window, define, require ) {


    /**
     * @fileOverview jQuery or Zepto
     */
    define('dollar-third',[],function() {
        return window.jQuery || window.Zepto;
    });
    /**
     * @fileOverview Dom 操作相关
     */
    define('dollar',[
        'dollar-third'
    ], function( _ ) {
        return _;
    });
    /**
     * @fileOverview 使用jQuery的Promise
     */
    define('promise-third',[
        'dollar'
    ], function( $ ) {
        return {
            Deferred: $.Deferred,
            when: $.when,
    
            isPromise: function( anything ) {
                return anything && typeof anything.then === 'function';
            }
        };
    });
    /**
     * @fileOverview Promise/A+
     */
    define('promise',[
        'promise-third'
    ], function( _ ) {
        return _;
    });
    /**
     * @fileOverview 基础类方法。
     */
    
    /**
     * Web Uploader内部类的详细说明，以下提及的功能类，都可以在`WebUploader`这个变量中访问到。
     *
     * As you know, Web Uploader的每个文件都是用过[AMD](https://github.com/amdjs/amdjs-api/wiki/AMD)规范中的`define`组织起来的, 每个Module都会有个module id.
     * 默认module id该文件的路径，而此路径将会转化成名字空间存放在WebUploader中。如：
     *
     * * module `base`：WebUploader.Base
     * * module `file`: WebUploader.File
     * * module `lib/dnd`: WebUploader.Lib.Dnd
     * * module `runtime/html5/dnd`: WebUploader.Runtime.Html5.Dnd
     *
     *
     * 以下文档将可能省略`WebUploader`前缀。
     * @module WebUploader
     * @title WebUploader API文档
     */
    define('base',[
        'dollar',
        'promise'
    ], function( $, promise ) {
    
        var noop = function() {},
            call = Function.call;
    
        // http://jsperf.com/uncurrythis
        // 反科里化
        function uncurryThis( fn ) {
            return function() {
                return call.apply( fn, arguments );
            };
        }
    
        function bindFn( fn, context ) {
            return function() {
                return fn.apply( context, arguments );
            };
        }
    
        function createObject( proto ) {
            var f;
    
            if ( Object.create ) {
                return Object.create( proto );
            } else {
                f = function() {};
                f.prototype = proto;
                return new f();
            }
        }
    
    
        /**
         * 基础类，提供一些简单常用的方法。
         * @class Base
         */
        return {
    
            /**
             * @property {String} version 当前版本号。
             */
            version: '0.1.2',
    
            /**
             * @property {jQuery|Zepto} $ 引用依赖的jQuery或者Zepto对象。
             */
            $: $,
    
            Deferred: promise.Deferred,
    
            isPromise: promise.isPromise,
    
            when: promise.when,
    
            /**
             * @description  简单的浏览器检查结果。
             *
             * * `webkit`  webkit版本号，如果浏览器为非webkit内核，此属性为`undefined`。
             * * `chrome`  chrome浏览器版本号，如果浏览器为chrome，此属性为`undefined`。
             * * `ie`  ie浏览器版本号，如果浏览器为非ie，此属性为`undefined`。**暂不支持ie10+**
             * * `firefox`  firefox浏览器版本号，如果浏览器为非firefox，此属性为`undefined`。
             * * `safari`  safari浏览器版本号，如果浏览器为非safari，此属性为`undefined`。
             * * `opera`  opera浏览器版本号，如果浏览器为非opera，此属性为`undefined`。
             *
             * @property {Object} [browser]
             */
            browser: (function( ua ) {
                var ret = {},
                    webkit = ua.match( /WebKit\/([\d.]+)/ ),
                    chrome = ua.match( /Chrome\/([\d.]+)/ ) ||
                        ua.match( /CriOS\/([\d.]+)/ ),
    
                    ie = ua.match( /MSIE\s([\d\.]+)/ ) ||
                        ua.match(/(?:trident)(?:.*rv:([\w.]+))?/i),
                    firefox = ua.match( /Firefox\/([\d.]+)/ ),
                    safari = ua.match( /Safari\/([\d.]+)/ ),
                    opera = ua.match( /OPR\/([\d.]+)/ );
    
                webkit && (ret.webkit = parseFloat( webkit[ 1 ] ));
                chrome && (ret.chrome = parseFloat( chrome[ 1 ] ));
                ie && (ret.ie = parseFloat( ie[ 1 ] ));
                firefox && (ret.firefox = parseFloat( firefox[ 1 ] ));
                safari && (ret.safari = parseFloat( safari[ 1 ] ));
                opera && (ret.opera = parseFloat( opera[ 1 ] ));
    
                return ret;
            })( navigator.userAgent ),
    
            /**
             * @description  操作系统检查结果。
             *
             * * `android`  如果在android浏览器环境下，此值为对应的android版本号，否则为`undefined`。
             * * `ios` 如果在ios浏览器环境下，此值为对应的ios版本号，否则为`undefined`。
             * @property {Object} [os]
             */
            os: (function( ua ) {
                var ret = {},
    
                    // osx = !!ua.match( /\(Macintosh\; Intel / ),
                    android = ua.match( /(?:Android);?[\s\/]+([\d.]+)?/ ),
                    ios = ua.match( /(?:iPad|iPod|iPhone).*OS\s([\d_]+)/ );
    
                // osx && (ret.osx = true);
                android && (ret.android = parseFloat( android[ 1 ] ));
                ios && (ret.ios = parseFloat( ios[ 1 ].replace( /_/g, '.' ) ));
    
                return ret;
            })( navigator.userAgent ),
    
            /**
             * 实现类与类之间的继承。
             * @method inherits
             * @grammar Base.inherits( super ) => child
             * @grammar Base.inherits( super, protos ) => child
             * @grammar Base.inherits( super, protos, statics ) => child
             * @param  {Class} super 父类
             * @param  {Object | Function} [protos] 子类或者对象。如果对象中包含constructor，子类将是用此属性值。
             * @param  {Function} [protos.constructor] 子类构造器，不指定的话将创建个临时的直接执行父类构造器的方法。
             * @param  {Object} [statics] 静态属性或方法。
             * @return {Class} 返回子类。
             * @example
             * function Person() {
             *     console.log( 'Super' );
             * }
             * Person.prototype.hello = function() {
             *     console.log( 'hello' );
             * };
             *
             * var Manager = Base.inherits( Person, {
             *     world: function() {
             *         console.log( 'World' );
             *     }
             * });
             *
             * // 因为没有指定构造器，父类的构造器将会执行。
             * var instance = new Manager();    // => Super
             *
             * // 继承子父类的方法
             * instance.hello();    // => hello
             * instance.world();    // => World
             *
             * // 子类的__super__属性指向父类
             * console.log( Manager.__super__ === Person );    // => true
             */
            inherits: function( Super, protos, staticProtos ) {
                var child;
    
                if ( typeof protos === 'function' ) {
                    child = protos;
                    protos = null;
                } else if ( protos && protos.hasOwnProperty('constructor') ) {
                    child = protos.constructor;
                } else {
                    child = function() {
                        return Super.apply( this, arguments );
                    };
                }
    
                // 复制静态方法
                $.extend( true, child, Super, staticProtos || {} );
    
                /* jshint camelcase: false */
    
                // 让子类的__super__属性指向父类。
                child.__super__ = Super.prototype;
    
                // 构建原型，添加原型方法或属性。
                // 暂时用Object.create实现。
                child.prototype = createObject( Super.prototype );
                protos && $.extend( true, child.prototype, protos );
    
                return child;
            },
    
            /**
             * 一个不做任何事情的方法。可以用来赋值给默认的callback.
             * @method noop
             */
            noop: noop,
    
            /**
             * 返回一个新的方法，此方法将已指定的`context`来执行。
             * @grammar Base.bindFn( fn, context ) => Function
             * @method bindFn
             * @example
             * var doSomething = function() {
             *         console.log( this.name );
             *     },
             *     obj = {
             *         name: 'Object Name'
             *     },
             *     aliasFn = Base.bind( doSomething, obj );
             *
             *  aliasFn();    // => Object Name
             *
             */
            bindFn: bindFn,
    
            /**
             * 引用Console.log如果存在的话，否则引用一个[空函数loop](#WebUploader:Base.log)。
             * @grammar Base.log( args... ) => undefined
             * @method log
             */
            log: (function() {
                if ( window.console ) {
                    return bindFn( console.log, console );
                }
                return noop;
            })(),
    
            nextTick: (function() {
    
                return function( cb ) {
                    setTimeout( cb, 1 );
                };
    
                // @bug 当浏览器不在当前窗口时就停了。
                // var next = window.requestAnimationFrame ||
                //     window.webkitRequestAnimationFrame ||
                //     window.mozRequestAnimationFrame ||
                //     function( cb ) {
                //         window.setTimeout( cb, 1000 / 60 );
                //     };
    
                // // fix: Uncaught TypeError: Illegal invocation
                // return bindFn( next, window );
            })(),
    
            /**
             * 被[uncurrythis](http://www.2ality.com/2011/11/uncurrying-this.html)的数组slice方法。
             * 将用来将非数组对象转化成数组对象。
             * @grammar Base.slice( target, start[, end] ) => Array
             * @method slice
             * @example
             * function doSomthing() {
             *     var args = Base.slice( arguments, 1 );
             *     console.log( args );
             * }
             *
             * doSomthing( 'ignored', 'arg2', 'arg3' );    // => Array ["arg2", "arg3"]
             */
            slice: uncurryThis( [].slice ),
    
            /**
             * 生成唯一的ID
             * @method guid
             * @grammar Base.guid() => String
             * @grammar Base.guid( prefx ) => String
             */
            guid: (function() {
                var counter = 0;
    
                return function( prefix ) {
                    var guid = (+new Date()).toString( 32 ),
                        i = 0;
    
                    for ( ; i < 5; i++ ) {
                        guid += Math.floor( Math.random() * 65535 ).toString( 32 );
                    }
    
                    return (prefix || 'wu_') + guid + (counter++).toString( 32 );
                };
            })(),
    
            /**
             * 格式化文件大小, 输出成带单位的字符串
             * @method formatSize
             * @grammar Base.formatSize( size ) => String
             * @grammar Base.formatSize( size, pointLength ) => String
             * @grammar Base.formatSize( size, pointLength, units ) => String
             * @param {Number} size 文件大小
             * @param {Number} [pointLength=2] 精确到的小数点数。
             * @param {Array} [units=[ 'B', 'K', 'M', 'G', 'TB' ]] 单位数组。从字节，到千字节，一直往上指定。如果单位数组里面只指定了到了K(千字节)，同时文件大小大于M, 此方法的输出将还是显示成多少K.
             * @example
             * console.log( Base.formatSize( 100 ) );    // => 100B
             * console.log( Base.formatSize( 1024 ) );    // => 1.00K
             * console.log( Base.formatSize( 1024, 0 ) );    // => 1K
             * console.log( Base.formatSize( 1024 * 1024 ) );    // => 1.00M
             * console.log( Base.formatSize( 1024 * 1024 * 1024 ) );    // => 1.00G
             * console.log( Base.formatSize( 1024 * 1024 * 1024, 0, ['B', 'KB', 'MB'] ) );    // => 1024MB
             */
            formatSize: function( size, pointLength, units ) {
                var unit;
    
                units = units || [ 'B', 'K', 'M', 'G', 'TB' ];
    
                while ( (unit = units.shift()) && size > 1024 ) {
                    size = size / 1024;
                }
    
                return (unit === 'B' ? size : size.toFixed( pointLength || 2 )) +
                        unit;
            }
        };
    });
    /**
     * 事件处理类，可以独立使用，也可以扩展给对象使用。
     * @fileOverview Mediator
     */
    define('mediator',[
        'base'
    ], function( Base ) {
        var $ = Base.$,
            slice = [].slice,
            separator = /\s+/,
            protos;
    
        // 根据条件过滤出事件handlers.
        function findHandlers( arr, name, callback, context ) {
            return $.grep( arr, function( handler ) {
                return handler &&
                        (!name || handler.e === name) &&
                        (!callback || handler.cb === callback ||
                        handler.cb._cb === callback) &&
                        (!context || handler.ctx === context);
            });
        }
    
        function eachEvent( events, callback, iterator ) {
            // 不支持对象，只支持多个event用空格隔开
            $.each( (events || '').split( separator ), function( _, key ) {
                iterator( key, callback );
            });
        }
    
        function triggerHanders( events, args ) {
            var stoped = false,
                i = -1,
                len = events.length,
                handler;
    
            while ( ++i < len ) {
                handler = events[ i ];
    
                if ( handler.cb.apply( handler.ctx2, args ) === false ) {
                    stoped = true;
                    break;
                }
            }
    
            return !stoped;
        }
    
        protos = {
    
            /**
             * 绑定事件。
             *
             * `callback`方法在执行时，arguments将会来源于trigger的时候携带的参数。如
             * ```javascript
             * var obj = {};
             *
             * // 使得obj有事件行为
             * Mediator.installTo( obj );
             *
             * obj.on( 'testa', function( arg1, arg2 ) {
             *     console.log( arg1, arg2 ); // => 'arg1', 'arg2'
             * });
             *
             * obj.trigger( 'testa', 'arg1', 'arg2' );
             * ```
             *
             * 如果`callback`中，某一个方法`return false`了，则后续的其他`callback`都不会被执行到。
             * 切会影响到`trigger`方法的返回值，为`false`。
             *
             * `on`还可以用来添加一个特殊事件`all`, 这样所有的事件触发都会响应到。同时此类`callback`中的arguments有一个不同处，
             * 就是第一个参数为`type`，记录当前是什么事件在触发。此类`callback`的优先级比脚低，会再正常`callback`执行完后触发。
             * ```javascript
             * obj.on( 'all', function( type, arg1, arg2 ) {
             *     console.log( type, arg1, arg2 ); // => 'testa', 'arg1', 'arg2'
             * });
             * ```
             *
             * @method on
             * @grammar on( name, callback[, context] ) => self
             * @param  {String}   name     事件名，支持多个事件用空格隔开
             * @param  {Function} callback 事件处理器
             * @param  {Object}   [context]  事件处理器的上下文。
             * @return {self} 返回自身，方便链式
             * @chainable
             * @class Mediator
             */
            on: function( name, callback, context ) {
                var me = this,
                    set;
    
                if ( !callback ) {
                    return this;
                }
    
                set = this._events || (this._events = []);
    
                eachEvent( name, callback, function( name, callback ) {
                    var handler = { e: name };
    
                    handler.cb = callback;
                    handler.ctx = context;
                    handler.ctx2 = context || me;
                    handler.id = set.length;
    
                    set.push( handler );
                });
    
                return this;
            },
    
            /**
             * 绑定事件，且当handler执行完后，自动解除绑定。
             * @method once
             * @grammar once( name, callback[, context] ) => self
             * @param  {String}   name     事件名
             * @param  {Function} callback 事件处理器
             * @param  {Object}   [context]  事件处理器的上下文。
             * @return {self} 返回自身，方便链式
             * @chainable
             */
            once: function( name, callback, context ) {
                var me = this;
    
                if ( !callback ) {
                    return me;
                }
    
                eachEvent( name, callback, function( name, callback ) {
                    var once = function() {
                            me.off( name, once );
                            return callback.apply( context || me, arguments );
                        };
    
                    once._cb = callback;
                    me.on( name, once, context );
                });
    
                return me;
            },
    
            /**
             * 解除事件绑定
             * @method off
             * @grammar off( [name[, callback[, context] ] ] ) => self
             * @param  {String}   [name]     事件名
             * @param  {Function} [callback] 事件处理器
             * @param  {Object}   [context]  事件处理器的上下文。
             * @return {self} 返回自身，方便链式
             * @chainable
             */
            off: function( name, cb, ctx ) {
                var events = this._events;
    
                if ( !events ) {
                    return this;
                }
    
                if ( !name && !cb && !ctx ) {
                    this._events = [];
                    return this;
                }
    
                eachEvent( name, cb, function( name, cb ) {
                    $.each( findHandlers( events, name, cb, ctx ), function() {
                        delete events[ this.id ];
                    });
                });
    
                return this;
            },
    
            /**
             * 触发事件
             * @method trigger
             * @grammar trigger( name[, args...] ) => self
             * @param  {String}   type     事件名
             * @param  {*} [...] 任意参数
             * @return {Boolean} 如果handler中return false了，则返回false, 否则返回true
             */
            trigger: function( type ) {
                var args, events, allEvents;
    
                if ( !this._events || !type ) {
                    return this;
                }
    
                args = slice.call( arguments, 1 );
                events = findHandlers( this._events, type );
                allEvents = findHandlers( this._events, 'all' );
    
                return triggerHanders( events, args ) &&
                        triggerHanders( allEvents, arguments );
            }
        };
    
        /**
         * 中介者，它本身是个单例，但可以通过[installTo](#WebUploader:Mediator:installTo)方法，使任何对象具备事件行为。
         * 主要目的是负责模块与模块之间的合作，降低耦合度。
         *
         * @class Mediator
         */
        return $.extend({
    
            /**
             * 可以通过这个接口，使任何对象具备事件功能。
             * @method installTo
             * @param  {Object} obj 需要具备事件行为的对象。
             * @return {Object} 返回obj.
             */
            installTo: function( obj ) {
                return $.extend( obj, protos );
            }
    
        }, protos );
    });
    /**
     * @fileOverview Uploader上传类
     */
    define('uploader',[
        'base',
        'mediator'
    ], function( Base, Mediator ) {
    
        var $ = Base.$;
    
        /**
         * 上传入口类。
         * @class Uploader
         * @constructor
         * @grammar new Uploader( opts ) => Uploader
         * @example
         * var uploader = WebUploader.Uploader({
         *     swf: 'path_of_swf/Uploader.swf',
         *
         *     // 开起分片上传。
         *     chunked: true
         * });
         */
        function Uploader( opts ) {
            this.options = $.extend( true, {}, Uploader.options, opts );
            this._init( this.options );
        }
    
        // default Options
        // widgets中有相应扩展
        Uploader.options = {};
        Mediator.installTo( Uploader.prototype );
    
        // 批量添加纯命令式方法。
        $.each({
            upload: 'start-upload',
            stop: 'stop-upload',
            getFile: 'get-file',
            getFiles: 'get-files',
            addFile: 'add-file',
            addFiles: 'add-file',
            sort: 'sort-files',
            removeFile: 'remove-file',
            skipFile: 'skip-file',
            retry: 'retry',
            isInProgress: 'is-in-progress',
            makeThumb: 'make-thumb',
            getDimension: 'get-dimension',
            addButton: 'add-btn',
            getRuntimeType: 'get-runtime-type',
            refresh: 'refresh',
            disable: 'disable',
            enable: 'enable',
            reset: 'reset'
        }, function( fn, command ) {
            Uploader.prototype[ fn ] = function() {
                return this.request( command, arguments );
            };
        });
    
        $.extend( Uploader.prototype, {
            state: 'pending',
    
            _init: function( opts ) {
                var me = this;
    
                me.request( 'init', opts, function() {
                    me.state = 'ready';
                    me.trigger('ready');
                });
            },
    
            /**
             * 获取或者设置Uploader配置项。
             * @method option
             * @grammar option( key ) => *
             * @grammar option( key, val ) => self
             * @example
             *
             * // 初始状态图片上传前不会压缩
             * var uploader = new WebUploader.Uploader({
             *     resize: null;
             * });
             *
             * // 修改后图片上传前，尝试将图片压缩到1600 * 1600
             * uploader.options( 'resize', {
             *     width: 1600,
             *     height: 1600
             * });
             */
            option: function( key, val ) {
                var opts = this.options;
    
                // setter
                if ( arguments.length > 1 ) {
    
                    if ( $.isPlainObject( val ) &&
                            $.isPlainObject( opts[ key ] ) ) {
                        $.extend( opts[ key ], val );
                    } else {
                        opts[ key ] = val;
                    }
    
                } else {    // getter
                    return key ? opts[ key ] : opts;
                }
            },
    
            /**
             * 获取文件统计信息。返回一个包含一下信息的对象。
             * * `successNum` 上传成功的文件数
             * * `uploadFailNum` 上传失败的文件数
             * * `cancelNum` 被删除的文件数
             * * `invalidNum` 无效的文件数
             * * `queueNum` 还在队列中的文件数
             * @method getStats
             * @grammar getStats() => Object
             */
            getStats: function() {
                // return this._mgr.getStats.apply( this._mgr, arguments );
                var stats = this.request('get-stats');
    
                return {
                    successNum: stats.numOfSuccess,
    
                    // who care?
                    // queueFailNum: 0,
                    cancelNum: stats.numOfCancel,
                    invalidNum: stats.numOfInvalid,
                    uploadFailNum: stats.numOfUploadFailed,
                    queueNum: stats.numOfQueue
                };
            },
    
            // 需要重写此方法来来支持opts.onEvent和instance.onEvent的处理器
            trigger: function( type/*, args...*/ ) {
                var args = [].slice.call( arguments, 1 ),
                    opts = this.options,
                    name = 'on' + type.substring( 0, 1 ).toUpperCase() +
                        type.substring( 1 );
    
                if (
                        // 调用通过on方法注册的handler.
                        Mediator.trigger.apply( this, arguments ) === false ||
    
                        // 调用opts.onEvent
                        $.isFunction( opts[ name ] ) &&
                        opts[ name ].apply( this, args ) === false ||
    
                        // 调用this.onEvent
                        $.isFunction( this[ name ] ) &&
                        this[ name ].apply( this, args ) === false ||
    
                        // 广播所有uploader的事件。
                        Mediator.trigger.apply( Mediator,
                        [ this, type ].concat( args ) ) === false ) {
    
                    return false;
                }
    
                return true;
            },
    
            // widgets/widget.js将补充此方法的详细文档。
            request: Base.noop
        });
    
        /**
         * 创建Uploader实例，等同于new Uploader( opts );
         * @method create
         * @class Base
         * @static
         * @grammar Base.create( opts ) => Uploader
         */
        Base.create = Uploader.create = function( opts ) {
            return new Uploader( opts );
        };
    
        // 暴露Uploader，可以通过它来扩展业务逻辑。
        Base.Uploader = Uploader;
    
        return Uploader;
    });
    /**
     * @fileOverview Runtime管理器，负责Runtime的选择, 连接
     */
    define('runtime/runtime',[
        'base',
        'mediator'
    ], function( Base, Mediator ) {
    
        var $ = Base.$,
            factories = {},
    
            // 获取对象的第一个key
            getFirstKey = function( obj ) {
                for ( var key in obj ) {
                    if ( obj.hasOwnProperty( key ) ) {
                        return key;
                    }
                }
                return null;
            };
    
        // 接口类。
        function Runtime( options ) {
            this.options = $.extend({
                container: document.body
            }, options );
            this.uid = Base.guid('rt_');
        }
    
        $.extend( Runtime.prototype, {
    
            getContainer: function() {
                var opts = this.options,
                    parent, container;
    
                if ( this._container ) {
                    return this._container;
                }
    
                parent = $( opts.container || document.body );
                container = $( document.createElement('div') );
    
                container.attr( 'id', 'rt_' + this.uid );
                container.css({
                    position: 'absolute',
                    top: '0px',
                    left: '0px',
                    width: '1px',
                    height: '1px',
                    overflow: 'hidden'
                });
    
                parent.append( container );
                parent.addClass('webuploader-container');
                this._container = container;
                return container;
            },
    
            init: Base.noop,
            exec: Base.noop,
    
            destroy: function() {
                if ( this._container ) {
                    this._container.parentNode.removeChild( this.__container );
                }
    
                this.off();
            }
        });
    
        Runtime.orders = 'html5,flash';
    
    
        /**
         * 添加Runtime实现。
         * @param {String} type    类型
         * @param {Runtime} factory 具体Runtime实现。
         */
        Runtime.addRuntime = function( type, factory ) {
            factories[ type ] = factory;
        };
    
        Runtime.hasRuntime = function( type ) {
            return !!(type ? factories[ type ] : getFirstKey( factories ));
        };
    
        Runtime.create = function( opts, orders ) {
            var type, runtime;
    
            orders = orders || Runtime.orders;
            $.each( orders.split( /\s*,\s*/g ), function() {
                if ( factories[ this ] ) {
                    type = this;
                    return false;
                }
            });
    
            type = type || getFirstKey( factories );
    
            if ( !type ) {
                throw new Error('Runtime Error');
            }
    
            runtime = new factories[ type ]( opts );
            return runtime;
        };
    
        Mediator.installTo( Runtime.prototype );
        return Runtime;
    });
    
    /**
     * @fileOverview Runtime管理器，负责Runtime的选择, 连接
     */
    define('runtime/client',[
        'base',
        'mediator',
        'runtime/runtime'
    ], function( Base, Mediator, Runtime ) {
    
        var cache;
    
        cache = (function() {
            var obj = {};
    
            return {
                add: function( runtime ) {
                    obj[ runtime.uid ] = runtime;
                },
    
                get: function( ruid, standalone ) {
                    var i;
    
                    if ( ruid ) {
                        return obj[ ruid ];
                    }
    
                    for ( i in obj ) {
                        // 有些类型不能重用，比如filepicker.
                        if ( standalone && obj[ i ].__standalone ) {
                            continue;
                        }
    
                        return obj[ i ];
                    }
    
                    return null;
                },
    
                remove: function( runtime ) {
                    delete obj[ runtime.uid ];
                }
            };
        })();
    
        function RuntimeClient( component, standalone ) {
            var deferred = Base.Deferred(),
                runtime;
    
            this.uid = Base.guid('client_');
    
            // 允许runtime没有初始化之前，注册一些方法在初始化后执行。
            this.runtimeReady = function( cb ) {
                return deferred.done( cb );
            };
    
            this.connectRuntime = function( opts, cb ) {
    
                // already connected.
                if ( runtime ) {
                    throw new Error('already connected!');
                }
    
                deferred.done( cb );
    
                if ( typeof opts === 'string' && cache.get( opts ) ) {
                    runtime = cache.get( opts );
                }
    
                // 像filePicker只能独立存在，不能公用。
                runtime = runtime || cache.get( null, standalone );
    
                // 需要创建
                if ( !runtime ) {
                    runtime = Runtime.create( opts, opts.runtimeOrder );
                    runtime.__promise = deferred.promise();
                    runtime.once( 'ready', deferred.resolve );
                    runtime.init();
                    cache.add( runtime );
                    runtime.__client = 1;
                } else {
                    // 来自cache
                    Base.$.extend( runtime.options, opts );
                    runtime.__promise.then( deferred.resolve );
                    runtime.__client++;
                }
    
                standalone && (runtime.__standalone = standalone);
                return runtime;
            };
    
            this.getRuntime = function() {
                return runtime;
            };
    
            this.disconnectRuntime = function() {
                if ( !runtime ) {
                    return;
                }
    
                runtime.__client--;
    
                if ( runtime.__client <= 0 ) {
                    cache.remove( runtime );
                    delete runtime.__promise;
                    runtime.destroy();
                }
    
                runtime = null;
            };
    
            this.exec = function() {
                if ( !runtime ) {
                    return;
                }
    
                var args = Base.slice( arguments );
                component && args.unshift( component );
    
                return runtime.exec.apply( this, args );
            };
    
            this.getRuid = function() {
                return runtime && runtime.uid;
            };
    
            this.destroy = (function( destroy ) {
                return function() {
                    destroy && destroy.apply( this, arguments );
                    this.trigger('destroy');
                    this.off();
                    this.exec('destroy');
                    this.disconnectRuntime();
                };
            })( this.destroy );
        }
    
        Mediator.installTo( RuntimeClient.prototype );
        return RuntimeClient;
    });
    /**
     * @fileOverview 错误信息
     */
    define('lib/dnd',[
        'base',
        'mediator',
        'runtime/client'
    ], function( Base, Mediator, RuntimeClent ) {
    
        var $ = Base.$;
    
        function DragAndDrop( opts ) {
            opts = this.options = $.extend({}, DragAndDrop.options, opts );
    
            opts.container = $( opts.container );
    
            if ( !opts.container.length ) {
                return;
            }
    
            RuntimeClent.call( this, 'DragAndDrop' );
        }
    
        DragAndDrop.options = {
            accept: null,
            disableGlobalDnd: false
        };
    
        Base.inherits( RuntimeClent, {
            constructor: DragAndDrop,
    
            init: function() {
                var me = this;
    
                me.connectRuntime( me.options, function() {
                    me.exec('init');
                    me.trigger('ready');
                });
            },
    
            destroy: function() {
                this.disconnectRuntime();
            }
        });
    
        Mediator.installTo( DragAndDrop.prototype );
    
        return DragAndDrop;
    });
    /**
     * @fileOverview 组件基类。
     */
    define('widgets/widget',[
        'base',
        'uploader'
    ], function( Base, Uploader ) {
    
        var $ = Base.$,
            _init = Uploader.prototype._init,
            IGNORE = {},
            widgetClass = [];
    
        function isArrayLike( obj ) {
            if ( !obj ) {
                return false;
            }
    
            var length = obj.length,
                type = $.type( obj );
    
            if ( obj.nodeType === 1 && length ) {
                return true;
            }
    
            return type === 'array' || type !== 'function' && type !== 'string' &&
                    (length === 0 || typeof length === 'number' && length > 0 &&
                    (length - 1) in obj);
        }
    
        function Widget( uploader ) {
            this.owner = uploader;
            this.options = uploader.options;
        }
    
        $.extend( Widget.prototype, {
    
            init: Base.noop,
    
            // 类Backbone的事件监听声明，监听uploader实例上的事件
            // widget直接无法监听事件，事件只能通过uploader来传递
            invoke: function( apiName, args ) {
    
                /*
                    {
                        'make-thumb': 'makeThumb'
                    }
                 */
                var map = this.responseMap;
    
                // 如果无API响应声明则忽略
                if ( !map || !(apiName in map) || !(map[ apiName ] in this) ||
                        !$.isFunction( this[ map[ apiName ] ] ) ) {
    
                    return IGNORE;
                }
    
                return this[ map[ apiName ] ].apply( this, args );
    
            },
    
            /**
             * 发送命令。当传入`callback`或者`handler`中返回`promise`时。返回一个当所有`handler`中的promise都完成后完成的新`promise`。
             * @method request
             * @grammar request( command, args ) => * | Promise
             * @grammar request( command, args, callback ) => Promise
             * @for  Uploader
             */
            request: function() {
                return this.owner.request.apply( this.owner, arguments );
            }
        });
    
        // 扩展Uploader.
        $.extend( Uploader.prototype, {
    
            // 覆写_init用来初始化widgets
            _init: function() {
                var me = this,
                    widgets = me._widgets = [];
    
                $.each( widgetClass, function( _, klass ) {
                    widgets.push( new klass( me ) );
                });
    
                return _init.apply( me, arguments );
            },
    
            request: function( apiName, args, callback ) {
                var i = 0,
                    widgets = this._widgets,
                    len = widgets.length,
                    rlts = [],
                    dfds = [],
                    widget, rlt, promise, key;
    
                args = isArrayLike( args ) ? args : [ args ];
    
                for ( ; i < len; i++ ) {
                    widget = widgets[ i ];
                    rlt = widget.invoke( apiName, args );
    
                    if ( rlt !== IGNORE ) {
    
                        // Deferred对象
                        if ( Base.isPromise( rlt ) ) {
                            dfds.push( rlt );
                        } else {
                            rlts.push( rlt );
                        }
                    }
                }
    
                // 如果有callback，则用异步方式。
                if ( callback || dfds.length ) {
                    promise = Base.when.apply( Base, dfds );
                    key = promise.pipe ? 'pipe' : 'then';
    
                    // 很重要不能删除。删除了会死循环。
                    // 保证执行顺序。让callback总是在下一个tick中执行。
                    return promise[ key ](function() {
                                var deferred = Base.Deferred(),
                                    args = arguments;
    
                                setTimeout(function() {
                                    deferred.resolve.apply( deferred, args );
                                }, 1 );
    
                                return deferred.promise();
                            })[ key ]( callback || Base.noop );
                } else {
                    return rlts[ 0 ];
                }
            }
        });
    
        /**
         * 添加组件
         * @param  {object} widgetProto 组件原型，构造函数通过constructor属性定义
         * @param  {object} responseMap API名称与函数实现的映射
         * @example
         *     Uploader.register( {
         *         init: function( options ) {},
         *         makeThumb: function() {}
         *     }, {
         *         'make-thumb': 'makeThumb'
         *     } );
         */
        Uploader.register = Widget.register = function( responseMap, widgetProto ) {
            var map = { init: 'init' },
                klass;
    
            if ( arguments.length === 1 ) {
                widgetProto = responseMap;
                widgetProto.responseMap = map;
            } else {
                widgetProto.responseMap = $.extend( map, responseMap );
            }
    
            klass = Base.inherits( Widget, widgetProto );
            widgetClass.push( klass );
    
            return klass;
        };
    
        return Widget;
    });
    /**
     * @fileOverview DragAndDrop Widget。
     */
    define('widgets/filednd',[
        'base',
        'uploader',
        'lib/dnd',
        'widgets/widget'
    ], function( Base, Uploader, Dnd ) {
        var $ = Base.$;
    
        Uploader.options.dnd = '';
    
        /**
         * @property {Selector} [dnd=undefined]  指定Drag And Drop拖拽的容器，如果不指定，则不启动。
         * @namespace options
         * @for Uploader
         */
    
        /**
         * @event dndAccept
         * @param {DataTransferItemList} items DataTransferItem
         * @description 阻止此事件可以拒绝某些类型的文件拖入进来。目前只有 chrome 提供这样的 API，且只能通过 mime-type 验证。
         * @for  Uploader
         */
        return Uploader.register({
            init: function( opts ) {
    
                if ( !opts.dnd ||
                        this.request('predict-runtime-type') !== 'html5' ) {
                    return;
                }
    
                var me = this,
                    deferred = Base.Deferred(),
                    options = $.extend({}, {
                        disableGlobalDnd: opts.disableGlobalDnd,
                        container: opts.dnd,
                        accept: opts.accept
                    }),
                    dnd;
    
                dnd = new Dnd( options );
    
                dnd.once( 'ready', deferred.resolve );
                dnd.on( 'drop', function( files ) {
                    me.request( 'add-file', [ files ]);
                });
    
                // 检测文件是否全部允许添加。
                dnd.on( 'accept', function( items ) {
                    return me.owner.trigger( 'dndAccept', items );
                });
    
                dnd.init();
    
                return deferred.promise();
            }
        });
    });
    
    /**
     * @fileOverview 错误信息
     */
    define('lib/filepaste',[
        'base',
        'mediator',
        'runtime/client'
    ], function( Base, Mediator, RuntimeClent ) {
    
        var $ = Base.$;
    
        function FilePaste( opts ) {
            opts = this.options = $.extend({}, opts );
            opts.container = $( opts.container || document.body );
            RuntimeClent.call( this, 'FilePaste' );
        }
    
        Base.inherits( RuntimeClent, {
            constructor: FilePaste,
    
            init: function() {
                var me = this;
    
                me.connectRuntime( me.options, function() {
                    me.exec('init');
                    me.trigger('ready');
                });
            },
    
            destroy: function() {
                this.exec('destroy');
                this.disconnectRuntime();
                this.off();
            }
        });
    
        Mediator.installTo( FilePaste.prototype );
    
        return FilePaste;
    });
    /**
     * @fileOverview 组件基类。
     */
    define('widgets/filepaste',[
        'base',
        'uploader',
        'lib/filepaste',
        'widgets/widget'
    ], function( Base, Uploader, FilePaste ) {
        var $ = Base.$;
    
        /**
         * @property {Selector} [paste=undefined]  指定监听paste事件的容器，如果不指定，不启用此功能。此功能为通过粘贴来添加截屏的图片。建议设置为`document.body`.
         * @namespace options
         * @for Uploader
         */
        return Uploader.register({
            init: function( opts ) {
    
                if ( !opts.paste ||
                        this.request('predict-runtime-type') !== 'html5' ) {
                    return;
                }
    
                var me = this,
                    deferred = Base.Deferred(),
                    options = $.extend({}, {
                        container: opts.paste,
                        accept: opts.accept
                    }),
                    paste;
    
                paste = new FilePaste( options );
    
                paste.once( 'ready', deferred.resolve );
                paste.on( 'paste', function( files ) {
                    me.owner.request( 'add-file', [ files ]);
                });
                paste.init();
    
                return deferred.promise();
            }
        });
    });
    /**
     * @fileOverview Blob
     */
    define('lib/blob',[
        'base',
        'runtime/client'
    ], function( Base, RuntimeClient ) {
    
        function Blob( ruid, source ) {
            var me = this;
    
            me.source = source;
            me.ruid = ruid;
    
            RuntimeClient.call( me, 'Blob' );
    
            this.uid = source.uid || this.uid;
            this.type = source.type || '';
            this.size = source.size || 0;
    
            if ( ruid ) {
                me.connectRuntime( ruid );
            }
        }
    
        Base.inherits( RuntimeClient, {
            constructor: Blob,
    
            slice: function( start, end ) {
                return this.exec( 'slice', start, end );
            },
    
            getSource: function() {
                return this.source;
            }
        });
    
        return Blob;
    });
    /**
     * 为了统一化Flash的File和HTML5的File而存在。
     * 以至于要调用Flash里面的File，也可以像调用HTML5版本的File一下。
     * @fileOverview File
     */
    define('lib/file',[
        'base',
        'lib/blob'
    ], function( Base, Blob ) {
    
        var uid = 1,
            rExt = /\.([^.]+)$/;
    
        function File( ruid, file ) {
            var ext;
    
            Blob.apply( this, arguments );
            this.name = file.name || ('untitled' + uid++);
            ext = rExt.exec( file.name ) ? RegExp.$1.toLowerCase() : '';
    
            // todo 支持其他类型文件的转换。
    
            // 如果有mimetype, 但是文件名里面没有找出后缀规律
            if ( !ext && this.type ) {
                ext = /\/(jpg|jpeg|png|gif|bmp)$/i.exec( this.type ) ?
                        RegExp.$1.toLowerCase() : '';
                this.name += '.' + ext;
            }
    
            // 如果没有指定mimetype, 但是知道文件后缀。
            if ( !this.type &&  ~'jpg,jpeg,png,gif,bmp'.indexOf( ext ) ) {
                this.type = 'image/' + (ext === 'jpg' ? 'jpeg' : ext);
            }
    
            this.ext = ext;
            this.lastModifiedDate = file.lastModifiedDate ||
                    (new Date()).toLocaleString();
        }
    
        return Base.inherits( Blob, File );
    });
    
    /**
     * @fileOverview 错误信息
     */
    define('lib/filepicker',[
        'base',
        'runtime/client',
        'lib/file'
    ], function( Base, RuntimeClent, File ) {
    
        var $ = Base.$;
    
        function FilePicker( opts ) {
            opts = this.options = $.extend({}, FilePicker.options, opts );
    
            opts.container = $( opts.id );
    
            if ( !opts.container.length ) {
                throw new Error('按钮指定错误');
            }
    
            opts.innerHTML = opts.innerHTML || opts.label ||
                    opts.container.html() || '';
    
            opts.button = $( opts.button || document.createElement('div') );
            opts.button.html( opts.innerHTML );
            opts.container.html( opts.button );
    
            RuntimeClent.call( this, 'FilePicker', true );
        }
    
        FilePicker.options = {
            button: null,
            container: null,
            label: null,
            innerHTML: null,
            multiple: true,
            accept: null,
            name: 'file'
        };
    
        Base.inherits( RuntimeClent, {
            constructor: FilePicker,
    
            init: function() {
                var me = this,
                    opts = me.options,
                    button = opts.button;
    
                button.addClass('webuploader-pick');
    
                me.on( 'all', function( type ) {
                    var files;
    
                    switch ( type ) {
                        case 'mouseenter':
                            button.addClass('webuploader-pick-hover');
                            break;
    
                        case 'mouseleave':
                            button.removeClass('webuploader-pick-hover');
                            break;
    
                        case 'change':
                            files = me.exec('getFiles');
                            me.trigger( 'select', $.map( files, function( file ) {
                                file = new File( me.getRuid(), file );
    
                                // 记录来源。
                                file._refer = opts.container;
                                return file;
                            }), opts.container );
                            break;
                    }
                });
    
                me.connectRuntime( opts, function() {
                    me.refresh();
                    me.exec( 'init', opts );
                    me.trigger('ready');
                });
    
                $( window ).on( 'resize', function() {
                    me.refresh();
                });
            },
    
            refresh: function() {
                var shimContainer = this.getRuntime().getContainer(),
                    button = this.options.button,
                    width = button.outerWidth ?
                            button.outerWidth() : button.width(),
    
                    height = button.outerHeight ?
                            button.outerHeight() : button.height(),
    
                    pos = button.offset();
    
                width && height && shimContainer.css({
                    bottom: 'auto',
                    right: 'auto',
                    width: width + 'px',
                    height: height + 'px'
                }).offset( pos );
            },
    
            enable: function() {
                var btn = this.options.button;
    
                btn.removeClass('webuploader-pick-disable');
                this.refresh();
            },
    
            disable: function() {
                var btn = this.options.button;
    
                this.getRuntime().getContainer().css({
                    top: '-99999px'
                });
    
                btn.addClass('webuploader-pick-disable');
            },
    
            destroy: function() {
                if ( this.runtime ) {
                    this.exec('destroy');
                    this.disconnectRuntime();
                }
            }
        });
    
        return FilePicker;
    });
    
    /**
     * @fileOverview 文件选择相关
     */
    define('widgets/filepicker',[
        'base',
        'uploader',
        'lib/filepicker',
        'widgets/widget'
    ], function( Base, Uploader, FilePicker ) {
        var $ = Base.$;
    
        $.extend( Uploader.options, {
    
            /**
             * @property {Selector | Object} [pick=undefined]
             * @namespace options
             * @for Uploader
             * @description 指定选择文件的按钮容器，不指定则不创建按钮。
             *
             * * `id` {Seletor} 指定选择文件的按钮容器，不指定则不创建按钮。
             * * `label` {String} 请采用 `innerHTML` 代替
             * * `innerHTML` {String} 指定按钮文字。不指定时优先从指定的容器中看是否自带文字。
             * * `multiple` {Boolean} 是否开起同时选择多个文件能力。
             */
            pick: null,
    
            /**
             * @property {Arroy} [accept=null]
             * @namespace options
             * @for Uploader
             * @description 指定接受哪些类型的文件。 由于目前还有ext转mimeType表，所以这里需要分开指定。
             *
             * * `title` {String} 文字描述
             * * `extensions` {String} 允许的文件后缀，不带点，多个用逗号分割。
             * * `mimeTypes` {String} 多个用逗号分割。
             *
             * 如：
             *
             * ```
             * {
             *     title: 'Images',
             *     extensions: 'gif,jpg,jpeg,bmp,png',
             *     mimeTypes: 'image/*'
             * }
             * ```
             */
            accept: null/*{
                title: 'Images',
                extensions: 'gif,jpg,jpeg,bmp,png',
                mimeTypes: 'image/*'
            }*/
        });
    
        return Uploader.register({
            'add-btn': 'addButton',
            refresh: 'refresh',
            disable: 'disable',
            enable: 'enable'
        }, {
    
            init: function( opts ) {
                this.pickers = [];
                return opts.pick && this.addButton( opts.pick );
            },
    
            refresh: function() {
                $.each( this.pickers, function() {
                    this.refresh();
                });
            },
    
            /**
             * @method addButton
             * @for Uploader
             * @grammar addButton( pick ) => Promise
             * @description
             * 添加文件选择按钮，如果一个按钮不够，需要调用此方法来添加。参数跟[options.pick](#WebUploader:Uploader:options)一致。
             * @example
             * uploader.addButton({
             *     id: '#btnContainer',
             *     innerHTML: '选择文件'
             * });
             */
            addButton: function( pick ) {
                var me = this,
                    opts = me.options,
                    accept = opts.accept,
                    options, picker, deferred;
    
                if ( !pick ) {
                    return;
                }
    
                deferred = Base.Deferred();
                $.isPlainObject( pick ) || (pick = {
                    id: pick
                });
    
                options = $.extend({}, pick, {
                    accept: $.isPlainObject( accept ) ? [ accept ] : accept,
                    swf: opts.swf,
                    runtimeOrder: opts.runtimeOrder
                });
    
                picker = new FilePicker( options );
    
                picker.once( 'ready', deferred.resolve );
                picker.on( 'select', function( files ) {
                    me.owner.request( 'add-file', [ files ]);
                });
                picker.init();
    
                this.pickers.push( picker );
    
                return deferred.promise();
            },
    
            disable: function() {
                $.each( this.pickers, function() {
                    this.disable();
                });
            },
    
            enable: function() {
                $.each( this.pickers, function() {
                    this.enable();
                });
            }
        });
    });
    /**
     * @fileOverview 文件属性封装
     */
    define('file',[
        'base',
        'mediator'
    ], function( Base, Mediator ) {
    
        var $ = Base.$,
            idPrefix = 'WU_FILE_',
            idSuffix = 0,
            rExt = /\.([^.]+)$/,
            statusMap = {};
    
        function gid() {
            return idPrefix + idSuffix++;
        }
    
        /**
         * 文件类
         * @class File
         * @constructor 构造函数
         * @grammar new File( source ) => File
         * @param {Lib.File} source [lib.File](#Lib.File)实例, 此source对象是带有Runtime信息的。
         */
        function WUFile( source ) {
    
            /**
             * 文件名，包括扩展名（后缀）
             * @property name
             * @type {string}
             */
            this.name = source.name || 'Untitled';
    
            /**
             * 文件体积（字节）
             * @property size
             * @type {uint}
             * @default 0
             */
            this.size = source.size || 0;
    
            /**
             * 文件MIMETYPE类型，与文件类型的对应关系请参考[http://t.cn/z8ZnFny](http://t.cn/z8ZnFny)
             * @property type
             * @type {string}
             * @default 'application'
             */
            this.type = source.type || 'application';
    
            /**
             * 文件最后修改日期
             * @property lastModifiedDate
             * @type {int}
             * @default 当前时间戳
             */
            this.lastModifiedDate = source.lastModifiedDate || (new Date() * 1);
    
            /**
             * 文件ID，每个对象具有唯一ID，与文件名无关
             * @property id
             * @type {string}
             */
            this.id = gid();
    
            /**
             * 文件扩展名，通过文件名获取，例如test.png的扩展名为png
             * @property ext
             * @type {string}
             */
            this.ext = rExt.exec( this.name ) ? RegExp.$1 : '';
    
    
            /**
             * 状态文字说明。在不同的status语境下有不同的用途。
             * @property statusText
             * @type {string}
             */
            this.statusText = '';
    
            // 存储文件状态，防止通过属性直接修改
            statusMap[ this.id ] = WUFile.Status.INITED;
    
            this.source = source;
            this.loaded = 0;
    
            this.on( 'error', function( msg ) {
                this.setStatus( WUFile.Status.ERROR, msg );
            });
        }
    
        $.extend( WUFile.prototype, {
    
            /**
             * 设置状态，状态变化时会触发`change`事件。
             * @method setStatus
             * @grammar setStatus( status[, statusText] );
             * @param {File.Status|String} status [文件状态值](#WebUploader:File:File.Status)
             * @param {String} [statusText=''] 状态说明，常在error时使用，用http, abort,server等来标记是由于什么原因导致文件错误。
             */
            setStatus: function( status, text ) {
    
                var prevStatus = statusMap[ this.id ];
    
                typeof text !== 'undefined' && (this.statusText = text);
    
                if ( status !== prevStatus ) {
                    statusMap[ this.id ] = status;
                    /**
                     * 文件状态变化
                     * @event statuschange
                     */
                    this.trigger( 'statuschange', status, prevStatus );
                }
    
            },
    
            /**
             * 获取文件状态
             * @return {File.Status}
             * @example
                     文件状态具体包括以下几种类型：
                     {
                         // 初始化
                        INITED:     0,
                        // 已入队列
                        QUEUED:     1,
                        // 正在上传
                        PROGRESS:     2,
                        // 上传出错
                        ERROR:         3,
                        // 上传成功
                        COMPLETE:     4,
                        // 上传取消
                        CANCELLED:     5
                    }
             */
            getStatus: function() {
                return statusMap[ this.id ];
            },
    
            /**
             * 获取文件原始信息。
             * @return {*}
             */
            getSource: function() {
                return this.source;
            },
    
            destory: function() {
                delete statusMap[ this.id ];
            }
        });
    
        Mediator.installTo( WUFile.prototype );
    
        /**
         * 文件状态值，具体包括以下几种类型：
         * * `inited` 初始状态
         * * `queued` 已经进入队列, 等待上传
         * * `progress` 上传中
         * * `complete` 上传完成。
         * * `error` 上传出错，可重试
         * * `interrupt` 上传中断，可续传。
         * * `invalid` 文件不合格，不能重试上传。会自动从队列中移除。
         * * `cancelled` 文件被移除。
         * @property {Object} Status
         * @namespace File
         * @class File
         * @static
         */
        WUFile.Status = {
            INITED:     'inited',    // 初始状态
            QUEUED:     'queued',    // 已经进入队列, 等待上传
            PROGRESS:   'progress',    // 上传中
            ERROR:      'error',    // 上传出错，可重试
            COMPLETE:   'complete',    // 上传完成。
            CANCELLED:  'cancelled',    // 上传取消。
            INTERRUPT:  'interrupt',    // 上传中断，可续传。
            INVALID:    'invalid'    // 文件不合格，不能重试上传。
        };
    
        return WUFile;
    });
    
    /**
     * @fileOverview 文件队列
     */
    define('queue',[
        'base',
        'mediator',
        'file'
    ], function( Base, Mediator, WUFile ) {
    
        var $ = Base.$,
            STATUS = WUFile.Status;
    
        /**
         * 文件队列, 用来存储各个状态中的文件。
         * @class Queue
         * @extends Mediator
         */
        function Queue() {
    
            /**
             * 统计文件数。
             * * `numOfQueue` 队列中的文件数。
             * * `numOfSuccess` 上传成功的文件数
             * * `numOfCancel` 被移除的文件数
             * * `numOfProgress` 正在上传中的文件数
             * * `numOfUploadFailed` 上传错误的文件数。
             * * `numOfInvalid` 无效的文件数。
             * @property {Object} stats
             */
            this.stats = {
                numOfQueue: 0,
                numOfSuccess: 0,
                numOfCancel: 0,
                numOfProgress: 0,
                numOfUploadFailed: 0,
                numOfInvalid: 0
            };
    
            // 上传队列，仅包括等待上传的文件
            this._queue = [];
    
            // 存储所有文件
            this._map = {};
        }
    
        $.extend( Queue.prototype, {
    
            /**
             * 将新文件加入对队列尾部
             *
             * @method append
             * @param  {File} file   文件对象
             */
            append: function( file ) {
                this._queue.push( file );
                this._fileAdded( file );
                return this;
            },
    
            /**
             * 将新文件加入对队列头部
             *
             * @method prepend
             * @param  {File} file   文件对象
             */
            prepend: function( file ) {
                this._queue.unshift( file );
                this._fileAdded( file );
                return this;
            },
    
            /**
             * 获取文件对象
             *
             * @method getFile
             * @param  {String} fileId   文件ID
             * @return {File}
             */
            getFile: function( fileId ) {
                if ( typeof fileId !== 'string' ) {
                    return fileId;
                }
                return this._map[ fileId ];
            },
    
            /**
             * 从队列中取出一个指定状态的文件。
             * @grammar fetch( status ) => File
             * @method fetch
             * @param {String} status [文件状态值](#WebUploader:File:File.Status)
             * @return {File} [File](#WebUploader:File)
             */
            fetch: function( status ) {
                var len = this._queue.length,
                    i, file;
    
                status = status || STATUS.QUEUED;
    
                for ( i = 0; i < len; i++ ) {
                    file = this._queue[ i ];
    
                    if ( status === file.getStatus() ) {
                        return file;
                    }
                }
    
                return null;
            },
    
            /**
             * 对队列进行排序，能够控制文件上传顺序。
             * @grammar sort( fn ) => undefined
             * @method sort
             * @param {Function} fn 排序方法
             */
            sort: function( fn ) {
                if ( typeof fn === 'function' ) {
                    this._queue.sort( fn );
                }
            },
    
            /**
             * 获取指定类型的文件列表, 列表中每一个成员为[File](#WebUploader:File)对象。
             * @grammar getFiles( [status1[, status2 ...]] ) => Array
             * @method getFiles
             * @param {String} [status] [文件状态值](#WebUploader:File:File.Status)
             */
            getFiles: function() {
                var sts = [].slice.call( arguments, 0 ),
                    ret = [],
                    i = 0,
                    len = this._queue.length,
                    file;
    
                for ( ; i < len; i++ ) {
                    file = this._queue[ i ];
    
                    if ( sts.length && !~$.inArray( file.getStatus(), sts ) ) {
                        continue;
                    }
    
                    ret.push( file );
                }
    
                return ret;
            },
    
            _fileAdded: function( file ) {
                var me = this,
                    existing = this._map[ file.id ];
    
                if ( !existing ) {
                    this._map[ file.id ] = file;
    
                    file.on( 'statuschange', function( cur, pre ) {
                        me._onFileStatusChange( cur, pre );
                    });
                }
    
                file.setStatus( STATUS.QUEUED );
            },
    
            _onFileStatusChange: function( curStatus, preStatus ) {
                var stats = this.stats;
    
                switch ( preStatus ) {
                    case STATUS.PROGRESS:
                        stats.numOfProgress--;
                        break;
    
                    case STATUS.QUEUED:
                        stats.numOfQueue --;
                        break;
    
                    case STATUS.ERROR:
                        stats.numOfUploadFailed--;
                        break;
    
                    case STATUS.INVALID:
                        stats.numOfInvalid--;
                        break;
                }
    
                switch ( curStatus ) {
                    case STATUS.QUEUED:
                        stats.numOfQueue++;
                        break;
    
                    case STATUS.PROGRESS:
                        stats.numOfProgress++;
                        break;
    
                    case STATUS.ERROR:
                        stats.numOfUploadFailed++;
                        break;
    
                    case STATUS.COMPLETE:
                        stats.numOfSuccess++;
                        break;
    
                    case STATUS.CANCELLED:
                        stats.numOfCancel++;
                        break;
    
                    case STATUS.INVALID:
                        stats.numOfInvalid++;
                        break;
                }
            }
    
        });
    
        Mediator.installTo( Queue.prototype );
    
        return Queue;
    });
    /**
     * @fileOverview 队列
     */
    define('widgets/queue',[
        'base',
        'uploader',
        'queue',
        'file',
        'lib/file',
        'runtime/client',
        'widgets/widget'
    ], function( Base, Uploader, Queue, WUFile, File, RuntimeClient ) {
    
        var $ = Base.$,
            rExt = /\.\w+$/,
            Status = WUFile.Status;
    
        return Uploader.register({
            'sort-files': 'sortFiles',
            'add-file': 'addFiles',
            'get-file': 'getFile',
            'fetch-file': 'fetchFile',
            'get-stats': 'getStats',
            'get-files': 'getFiles',
            'remove-file': 'removeFile',
            'retry': 'retry',
            'reset': 'reset',
            'accept-file': 'acceptFile'
        }, {
    
            init: function( opts ) {
                var me = this,
                    deferred, len, i, item, arr, accept, runtime;
    
                if ( $.isPlainObject( opts.accept ) ) {
                    opts.accept = [ opts.accept ];
                }
    
                // accept中的中生成匹配正则。
                if ( opts.accept ) {
                    arr = [];
    
                    for ( i = 0, len = opts.accept.length; i < len; i++ ) {
                        item = opts.accept[ i ].extensions;
                        item && arr.push( item );
                    }
    
                    if ( arr.length ) {
                        accept = '\\.' + arr.join(',')
                                .replace( /,/g, '$|\\.' )
                                .replace( /\*/g, '.*' ) + '$';
                    }
    
                    me.accept = new RegExp( accept, 'i' );
                }
    
                me.queue = new Queue();
                me.stats = me.queue.stats;
    
                // 如果当前不是html5运行时，那就算了。
                // 不执行后续操作
                if ( this.request('predict-runtime-type') !== 'html5' ) {
                    return;
                }
    
                // 创建一个 html5 运行时的 placeholder
                // 以至于外部添加原生 File 对象的时候能正确包裹一下供 webuploader 使用。
                deferred = Base.Deferred();
                runtime = new RuntimeClient('Placeholder');
                runtime.connectRuntime({
                    runtimeOrder: 'html5'
                }, function() {
                    me._ruid = runtime.getRuid();
                    deferred.resolve();
                });
                return deferred.promise();
            },
    
    
            // 为了支持外部直接添加一个原生File对象。
            _wrapFile: function( file ) {
                if ( !(file instanceof WUFile) ) {
    
                    if ( !(file instanceof File) ) {
                        if ( !this._ruid ) {
                            throw new Error('Can\'t add external files.');
                        }
                        file = new File( this._ruid, file );
                    }
    
                    file = new WUFile( file );
                }
    
                return file;
            },
    
            // 判断文件是否可以被加入队列
            acceptFile: function( file ) {
                var invalid = !file || file.size < 6 || this.accept &&
    
                        // 如果名字中有后缀，才做后缀白名单处理。
                        rExt.exec( file.name ) && !this.accept.test( file.name );
    
                return !invalid;
            },
    
    
            /**
             * @event beforeFileQueued
             * @param {File} file File对象
             * @description 当文件被加入队列之前触发，此事件的handler返回值为`false`，则此文件不会被添加进入队列。
             * @for  Uploader
             */
    
            /**
             * @event fileQueued
             * @param {File} file File对象
             * @description 当文件被加入队列以后触发。
             * @for  Uploader
             */
    
            _addFile: function( file ) {
                var me = this;
    
                file = me._wrapFile( file );
    
                // 不过类型判断允许不允许，先派送 `beforeFileQueued`
                if ( !me.owner.trigger( 'beforeFileQueued', file ) ) {
                    return;
                }
    
                // 类型不匹配，则派送错误事件，并返回。
                if ( !me.acceptFile( file ) ) {
                    me.owner.trigger( 'error', 'Q_TYPE_DENIED', file );
                    return;
                }
    
                me.queue.append( file );
                me.owner.trigger( 'fileQueued', file );
                return file;
            },
    
            getFile: function( fileId ) {
                return this.queue.getFile( fileId );
            },
    
            /**
             * @event filesQueued
             * @param {File} files 数组，内容为原始File(lib/File）对象。
             * @description 当一批文件添加进队列以后触发。
             * @for  Uploader
             */
    
            /**
             * @method addFiles
             * @grammar addFiles( file ) => undefined
             * @grammar addFiles( [file1, file2 ...] ) => undefined
             * @param {Array of File or File} [files] Files 对象 数组
             * @description 添加文件到队列
             * @for  Uploader
             */
            addFiles: function( files ) {
                var me = this;
    
                if ( !files.length ) {
                    files = [ files ];
                }
    
                files = $.map( files, function( file ) {
                    return me._addFile( file );
                });
    
                me.owner.trigger( 'filesQueued', files );
    
                if ( me.options.auto ) {
                    me.request('start-upload');
                }
            },
    
            getStats: function() {
                return this.stats;
            },
    
            /**
             * @event fileDequeued
             * @param {File} file File对象
             * @description 当文件被移除队列后触发。
             * @for  Uploader
             */
    
            /**
             * @method removeFile
             * @grammar removeFile( file ) => undefined
             * @grammar removeFile( id ) => undefined
             * @param {File|id} file File对象或这File对象的id
             * @description 移除某一文件。
             * @for  Uploader
             * @example
             *
             * $li.on('click', '.remove-this', function() {
             *     uploader.removeFile( file );
             * })
             */
            removeFile: function( file ) {
                var me = this;
    
                file = file.id ? file : me.queue.getFile( file );
    
                file.setStatus( Status.CANCELLED );
                me.owner.trigger( 'fileDequeued', file );
            },
    
            /**
             * @method getFiles
             * @grammar getFiles() => Array
             * @grammar getFiles( status1, status2, status... ) => Array
             * @description 返回指定状态的文件集合，不传参数将返回所有状态的文件。
             * @for  Uploader
             * @example
             * console.log( uploader.getFiles() );    // => all files
             * console.log( uploader.getFiles('error') )    // => all error files.
             */
            getFiles: function() {
                return this.queue.getFiles.apply( this.queue, arguments );
            },
    
            fetchFile: function() {
                return this.queue.fetch.apply( this.queue, arguments );
            },
    
            /**
             * @method retry
             * @grammar retry() => undefined
             * @grammar retry( file ) => undefined
             * @description 重试上传，重试指定文件，或者从出错的文件开始重新上传。
             * @for  Uploader
             * @example
             * function retry() {
             *     uploader.retry();
             * }
             */
            retry: function( file, noForceStart ) {
                var me = this,
                    files, i, len;
    
                if ( file ) {
                    file = file.id ? file : me.queue.getFile( file );
                    file.setStatus( Status.QUEUED );
                    noForceStart || me.request('start-upload');
                    return;
                }
    
                files = me.queue.getFiles( Status.ERROR );
                i = 0;
                len = files.length;
    
                for ( ; i < len; i++ ) {
                    file = files[ i ];
                    file.setStatus( Status.QUEUED );
                }
    
                me.request('start-upload');
            },
    
            /**
             * @method sort
             * @grammar sort( fn ) => undefined
             * @description 排序队列中的文件，在上传之前调整可以控制上传顺序。
             * @for  Uploader
             */
            sortFiles: function() {
                return this.queue.sort.apply( this.queue, arguments );
            },
    
            /**
             * @method reset
             * @grammar reset() => undefined
             * @description 重置uploader。目前只重置了队列。
             * @for  Uploader
             * @example
             * uploader.reset();
             */
            reset: function() {
                this.queue = new Queue();
                this.stats = this.queue.stats;
            }
        });
    
    });
    /**
     * @fileOverview 添加获取Runtime相关信息的方法。
     */
    define('widgets/runtime',[
        'uploader',
        'runtime/runtime',
        'widgets/widget'
    ], function( Uploader, Runtime ) {
    
        Uploader.support = function() {
            return Runtime.hasRuntime.apply( Runtime, arguments );
        };
    
        return Uploader.register({
            'predict-runtime-type': 'predictRuntmeType'
        }, {
    
            init: function() {
                if ( !this.predictRuntmeType() ) {
                    throw Error('Runtime Error');
                }
            },
    
            /**
             * 预测Uploader将采用哪个`Runtime`
             * @grammar predictRuntmeType() => String
             * @method predictRuntmeType
             * @for  Uploader
             */
            predictRuntmeType: function() {
                var orders = this.options.runtimeOrder || Runtime.orders,
                    type = this.type,
                    i, len;
    
                if ( !type ) {
                    orders = orders.split( /\s*,\s*/g );
    
                    for ( i = 0, len = orders.length; i < len; i++ ) {
                        if ( Runtime.hasRuntime( orders[ i ] ) ) {
                            this.type = type = orders[ i ];
                            break;
                        }
                    }
                }
    
                return type;
            }
        });
    });
    /**
     * @fileOverview Transport
     */
    define('lib/transport',[
        'base',
        'runtime/client',
        'mediator'
    ], function( Base, RuntimeClient, Mediator ) {
    
        var $ = Base.$;
    
        function Transport( opts ) {
            var me = this;
    
            opts = me.options = $.extend( true, {}, Transport.options, opts || {} );
            RuntimeClient.call( this, 'Transport' );
    
            this._blob = null;
            this._formData = opts.formData || {};
            this._headers = opts.headers || {};
    
            this.on( 'progress', this._timeout );
            this.on( 'load error', function() {
                me.trigger( 'progress', 1 );
                clearTimeout( me._timer );
            });
        }
    
        Transport.options = {
            server: '',
            method: 'POST',
    
            // 跨域时，是否允许携带cookie, 只有html5 runtime才有效
            withCredentials: false,
            fileVal: 'file',
            timeout: 2 * 60 * 1000,    // 2分钟
            formData: {},
            headers: {},
            sendAsBinary: false
        };
    
        $.extend( Transport.prototype, {
    
            // 添加Blob, 只能添加一次，最后一次有效。
            appendBlob: function( key, blob, filename ) {
                var me = this,
                    opts = me.options;
    
                if ( me.getRuid() ) {
                    me.disconnectRuntime();
                }
    
                // 连接到blob归属的同一个runtime.
                me.connectRuntime( blob.ruid, function() {
                    me.exec('init');
                });
    
                me._blob = blob;
                opts.fileVal = key || opts.fileVal;
                opts.filename = filename || opts.filename;
            },
    
            // 添加其他字段
            append: function( key, value ) {
                if ( typeof key === 'object' ) {
                    $.extend( this._formData, key );
                } else {
                    this._formData[ key ] = value;
                }
            },
    
            setRequestHeader: function( key, value ) {
                if ( typeof key === 'object' ) {
                    $.extend( this._headers, key );
                } else {
                    this._headers[ key ] = value;
                }
            },
    
            send: function( method ) {
                this.exec( 'send', method );
                this._timeout();
            },
    
            abort: function() {
                clearTimeout( this._timer );
                return this.exec('abort');
            },
    
            destroy: function() {
                this.trigger('destroy');
                this.off();
                this.exec('destroy');
                this.disconnectRuntime();
            },
    
            getResponse: function() {
                return this.exec('getResponse');
            },
    
            getResponseAsJson: function() {
                return this.exec('getResponseAsJson');
            },
    
            getStatus: function() {
                return this.exec('getStatus');
            },
    
            _timeout: function() {
                var me = this,
                    duration = me.options.timeout;
    
                if ( !duration ) {
                    return;
                }
    
                clearTimeout( me._timer );
                me._timer = setTimeout(function() {
                    me.abort();
                    me.trigger( 'error', 'timeout' );
                }, duration );
            }
    
        });
    
        // 让Transport具备事件功能。
        Mediator.installTo( Transport.prototype );
    
        return Transport;
    });
    /**
     * @fileOverview 负责文件上传相关。
     */
    define('widgets/upload',[
        'base',
        'uploader',
        'file',
        'lib/transport',
        'widgets/widget'
    ], function( Base, Uploader, WUFile, Transport ) {
    
        var $ = Base.$,
            isPromise = Base.isPromise,
            Status = WUFile.Status;
    
        // 添加默认配置项
        $.extend( Uploader.options, {
    
    
            /**
             * @property {Boolean} [prepareNextFile=false]
             * @namespace options
             * @for Uploader
             * @description 是否允许在文件传输时提前把下一个文件准备好。
             * 对于一个文件的准备工作比较耗时，比如图片压缩，md5序列化。
             * 如果能提前在当前文件传输期处理，可以节省总体耗时。
             */
            prepareNextFile: false,
    
            /**
             * @property {Boolean} [chunked=false]
             * @namespace options
             * @for Uploader
             * @description 是否要分片处理大文件上传。
             */
            chunked: false,
    
            /**
             * @property {Boolean} [chunkSize=5242880]
             * @namespace options
             * @for Uploader
             * @description 如果要分片，分多大一片？ 默认大小为5M.
             */
            chunkSize: 5 * 1024 * 1024,
    
            /**
             * @property {Boolean} [chunkRetry=2]
             * @namespace options
             * @for Uploader
             * @description 如果某个分片由于网络问题出错，允许自动重传多少次？
             */
            chunkRetry: 2,
    
            /**
             * @property {Boolean} [threads=3]
             * @namespace options
             * @for Uploader
             * @description 上传并发数。允许同时最大上传进程数。
             */
            threads: 3,
    
    
            /**
             * @property {Object} [formData]
             * @namespace options
             * @for Uploader
             * @description 文件上传请求的参数表，每次发送都会发送此对象中的参数。
             */
            formData: null
    
            /**
             * @property {Object} [fileVal='file']
             * @namespace options
             * @for Uploader
             * @description 设置文件上传域的name。
             */
    
            /**
             * @property {Object} [method='POST']
             * @namespace options
             * @for Uploader
             * @description 文件上传方式，`POST`或者`GET`。
             */
    
            /**
             * @property {Object} [sendAsBinary=false]
             * @namespace options
             * @for Uploader
             * @description 是否已二进制的流的方式发送文件，这样整个上传内容`php://input`都为文件内容，
             * 其他参数在$_GET数组中。
             */
        });
    
        // 负责将文件切片。
        function CuteFile( file, chunkSize ) {
            var pending = [],
                blob = file.source,
                total = blob.size,
                chunks = chunkSize ? Math.ceil( total / chunkSize ) : 1,
                start = 0,
                index = 0,
                len;
    
            while ( index < chunks ) {
                len = Math.min( chunkSize, total - start );
    
                pending.push({
                    file: file,
                    start: start,
                    end: chunkSize ? (start + len) : total,
                    total: total,
                    chunks: chunks,
                    chunk: index++
                });
                start += len;
            }
    
            file.blocks = pending.concat();
            file.remaning = pending.length;
    
            return {
                file: file,
    
                has: function() {
                    return !!pending.length;
                },
    
                fetch: function() {
                    return pending.shift();
                }
            };
        }
    
        Uploader.register({
            'start-upload': 'start',
            'stop-upload': 'stop',
            'skip-file': 'skipFile',
            'is-in-progress': 'isInProgress'
        }, {
    
            init: function() {
                var owner = this.owner;
    
                this.runing = false;
    
                // 记录当前正在传的数据，跟threads相关
                this.pool = [];
    
                // 缓存即将上传的文件。
                this.pending = [];
    
                // 跟踪还有多少分片没有完成上传。
                this.remaning = 0;
                this.__tick = Base.bindFn( this._tick, this );
    
                owner.on( 'uploadComplete', function( file ) {
                    // 把其他块取消了。
                    file.blocks && $.each( file.blocks, function( _, v ) {
                        v.transport && (v.transport.abort(), v.transport.destroy());
                        delete v.transport;
                    });
    
                    delete file.blocks;
                    delete file.remaning;
                });
            },
    
            /**
             * @event startUpload
             * @description 当开始上传流程时触发。
             * @for  Uploader
             */
    
            /**
             * 开始上传。此方法可以从初始状态调用开始上传流程，也可以从暂停状态调用，继续上传流程。
             * @grammar upload() => undefined
             * @method upload
             * @for  Uploader
             */
            start: function() {
                var me = this;
    
                // 移出invalid的文件
                $.each( me.request( 'get-files', Status.INVALID ), function() {
                    me.request( 'remove-file', this );
                });
    
                if ( me.runing ) {
                    return;
                }
    
                me.runing = true;
    
                // 如果有暂停的，则续传
                $.each( me.pool, function( _, v ) {
                    var file = v.file;
    
                    if ( file.getStatus() === Status.INTERRUPT ) {
                        file.setStatus( Status.PROGRESS );
                        me._trigged = false;
                        v.transport && v.transport.send();
                    }
                });
    
                me._trigged = false;
                me.owner.trigger('startUpload');
                Base.nextTick( me.__tick );
            },
    
            /**
             * @event stopUpload
             * @description 当开始上传流程暂停时触发。
             * @for  Uploader
             */
    
            /**
             * 暂停上传。第一个参数为是否中断上传当前正在上传的文件。
             * @grammar stop() => undefined
             * @grammar stop( true ) => undefined
             * @method stop
             * @for  Uploader
             */
            stop: function( interrupt ) {
                var me = this;
    
                if ( me.runing === false ) {
                    return;
                }
    
                me.runing = false;
    
                interrupt && $.each( me.pool, function( _, v ) {
                    v.transport && v.transport.abort();
                    v.file.setStatus( Status.INTERRUPT );
                });
    
                me.owner.trigger('stopUpload');
            },
    
            /**
             * 判断`Uplaode`r是否正在上传中。
             * @grammar isInProgress() => Boolean
             * @method isInProgress
             * @for  Uploader
             */
            isInProgress: function() {
                return !!this.runing;
            },
    
            getStats: function() {
                return this.request('get-stats');
            },
    
            /**
             * 掉过一个文件上传，直接标记指定文件为已上传状态。
             * @grammar skipFile( file ) => undefined
             * @method skipFile
             * @for  Uploader
             */
            skipFile: function( file, status ) {
                file = this.request( 'get-file', file );
    
                file.setStatus( status || Status.COMPLETE );
                file.skipped = true;
    
                // 如果正在上传。
                file.blocks && $.each( file.blocks, function( _, v ) {
                    var _tr = v.transport;
    
                    if ( _tr ) {
                        _tr.abort();
                        _tr.destroy();
                        delete v.transport;
                    }
                });
    
                this.owner.trigger( 'uploadSkip', file );
            },
    
            /**
             * @event uploadFinished
             * @description 当所有文件上传结束时触发。
             * @for  Uploader
             */
            _tick: function() {
                var me = this,
                    opts = me.options,
                    fn, val;
    
                // 上一个promise还没有结束，则等待完成后再执行。
                if ( me._promise ) {
                    return me._promise.always( me.__tick );
                }
    
                // 还有位置，且还有文件要处理的话。
                if ( me.pool.length < opts.threads && (val = me._nextBlock()) ) {
                    me._trigged = false;
    
                    fn = function( val ) {
                        me._promise = null;
    
                        // 有可能是reject过来的，所以要检测val的类型。
                        val && val.file && me._startSend( val );
                        Base.nextTick( me.__tick );
                    };
    
                    me._promise = isPromise( val ) ? val.always( fn ) : fn( val );
    
                // 没有要上传的了，且没有正在传输的了。
                } else if ( !me.remaning && !me.getStats().numOfQueue ) {
                    me.runing = false;
    
                    me._trigged || Base.nextTick(function() {
                        me.owner.trigger('uploadFinished');
                    });
                    me._trigged = true;
                }
            },
    
            _nextBlock: function() {
                var me = this,
                    act = me._act,
                    opts = me.options,
                    next, done;
    
                // 如果当前文件还有没有需要传输的，则直接返回剩下的。
                if ( act && act.has() &&
                        act.file.getStatus() === Status.PROGRESS ) {
    
                    // 是否提前准备下一个文件
                    if ( opts.prepareNextFile && !me.pending.length ) {
                        me._prepareNextFile();
                    }
    
                    return act.fetch();
    
                // 否则，如果正在运行，则准备下一个文件，并等待完成后返回下个分片。
                } else if ( me.runing ) {
    
                    // 如果缓存中有，则直接在缓存中取，没有则去queue中取。
                    if ( !me.pending.length && me.getStats().numOfQueue ) {
                        me._prepareNextFile();
                    }
    
                    next = me.pending.shift();
                    done = function( file ) {
                        if ( !file ) {
                            return null;
                        }
    
                        act = CuteFile( file, opts.chunked ? opts.chunkSize : 0 );
                        me._act = act;
                        return act.fetch();
                    };
    
                    // 文件可能还在prepare中，也有可能已经完全准备好了。
                    return isPromise( next ) ?
                            next[ next.pipe ? 'pipe' : 'then']( done ) :
                            done( next );
                }
            },
    
    
            /**
             * @event uploadStart
             * @param {File} file File对象
             * @description 某个文件开始上传前触发，一个文件只会触发一次。
             * @for  Uploader
             */
            _prepareNextFile: function() {
                var me = this,
                    file = me.request('fetch-file'),
                    pending = me.pending,
                    promise;
    
                if ( file ) {
                    promise = me.request( 'before-send-file', file, function() {
    
                        // 有可能文件被skip掉了。文件被skip掉后，状态坑定不是Queued.
                        if ( file.getStatus() === Status.QUEUED ) {
                            me.owner.trigger( 'uploadStart', file );
                            file.setStatus( Status.PROGRESS );
                            return file;
                        }
    
                        return me._finishFile( file );
                    });
    
                    // 如果还在pending中，则替换成文件本身。
                    promise.done(function() {
                        var idx = $.inArray( promise, pending );
    
                        ~idx && pending.splice( idx, 1, file );
                    });
    
                    // befeore-send-file的钩子就有错误发生。
                    promise.fail(function( reason ) {
                        file.setStatus( Status.ERROR, reason );
                        me.owner.trigger( 'uploadError', file, reason );
                        me.owner.trigger( 'uploadComplete', file );
                    });
    
                    pending.push( promise );
                }
            },
    
            // 让出位置了，可以让其他分片开始上传
            _popBlock: function( block ) {
                var idx = $.inArray( block, this.pool );
    
                this.pool.splice( idx, 1 );
                block.file.remaning--;
                this.remaning--;
            },
    
            // 开始上传，可以被掉过。如果promise被reject了，则表示跳过此分片。
            _startSend: function( block ) {
                var me = this,
                    file = block.file,
                    promise;
    
                me.pool.push( block );
                me.remaning++;
    
                // 如果没有分片，则直接使用原始的。
                // 不会丢失content-type信息。
                block.blob = block.chunks === 1 ? file.source :
                        file.source.slice( block.start, block.end );
    
                // hook, 每个分片发送之前可能要做些异步的事情。
                promise = me.request( 'before-send', block, function() {
    
                    // 有可能文件已经上传出错了，所以不需要再传输了。
                    if ( file.getStatus() === Status.PROGRESS ) {
                        me._doSend( block );
                    } else {
                        me._popBlock( block );
                        Base.nextTick( me.__tick );
                    }
                });
    
                // 如果为fail了，则跳过此分片。
                promise.fail(function() {
                    if ( file.remaning === 1 ) {
                        me._finishFile( file ).always(function() {
                            block.percentage = 1;
                            me._popBlock( block );
                            me.owner.trigger( 'uploadComplete', file );
                            Base.nextTick( me.__tick );
                        });
                    } else {
                        block.percentage = 1;
                        me._popBlock( block );
                        Base.nextTick( me.__tick );
                    }
                });
            },
    
    
            /**
             * @event uploadBeforeSend
             * @param {Object} object
             * @param {Object} data 默认的上传参数，可以扩展此对象来控制上传参数。
             * @description 当某个文件的分块在发送前触发，主要用来询问是否要添加附带参数，大文件在开起分片上传的前提下此事件可能会触发多次。
             * @for  Uploader
             */
    
            /**
             * @event uploadAccept
             * @param {Object} object
             * @param {Object} ret 服务端的返回数据，json格式，如果服务端不是json格式，从ret._raw中取数据，自行解析。
             * @description 当某个文件上传到服务端响应后，会派送此事件来询问服务端响应是否有效。如果此事件handler返回值为`false`, 则此文件将派送`server`类型的`uploadError`事件。
             * @for  Uploader
             */
    
            /**
             * @event uploadProgress
             * @param {File} file File对象
             * @param {Number} percentage 上传进度
             * @description 上传过程中触发，携带上传进度。
             * @for  Uploader
             */
    
    
            /**
             * @event uploadError
             * @param {File} file File对象
             * @param {String} reason 出错的code
             * @description 当文件上传出错时触发。
             * @for  Uploader
             */
    
            /**
             * @event uploadSuccess
             * @param {File} file File对象
             * @param {Object} response 服务端返回的数据
             * @description 当文件上传成功时触发。
             * @for  Uploader
             */
    
            /**
             * @event uploadComplete
             * @param {File} [file] File对象
             * @description 不管成功或者失败，文件上传完成时触发。
             * @for  Uploader
             */
    
            // 做上传操作。
            _doSend: function( block ) {
                var me = this,
                    owner = me.owner,
                    opts = me.options,
                    file = block.file,
                    tr = new Transport( opts ),
                    data = $.extend({}, opts.formData ),
                    headers = $.extend({}, opts.headers ),
                    requestAccept, ret;
    
                block.transport = tr;
    
                tr.on( 'destroy', function() {
                    delete block.transport;
                    me._popBlock( block );
                    Base.nextTick( me.__tick );
                });
    
                // 广播上传进度。以文件为单位。
                tr.on( 'progress', function( percentage ) {
                    var totalPercent = 0,
                        uploaded = 0;
    
                    // 可能没有abort掉，progress还是执行进来了。
                    // if ( !file.blocks ) {
                    //     return;
                    // }
    
                    totalPercent = block.percentage = percentage;
    
                    if ( block.chunks > 1 ) {    // 计算文件的整体速度。
                        $.each( file.blocks, function( _, v ) {
                            uploaded += (v.percentage || 0) * (v.end - v.start);
                        });
    
                        totalPercent = uploaded / file.size;
                    }
    
                    owner.trigger( 'uploadProgress', file, totalPercent || 0 );
                });
    
                // 用来询问，是否返回的结果是有错误的。
                requestAccept = function( reject ) {
                    var fn;
    
                    ret = tr.getResponseAsJson() || {};
                    ret._raw = tr.getResponse();
                    fn = function( value ) {
                        reject = value;
                    };
    
                    // 服务端响应了，不代表成功了，询问是否响应正确。
                    if ( !owner.trigger( 'uploadAccept', block, ret, fn ) ) {
                        reject = reject || 'server';
                    }
    
                    return reject;
                };
    
                // 尝试重试，然后广播文件上传出错。
                tr.on( 'error', function( type, flag ) {
                    block.retried = block.retried || 0;
    
                    // 自动重试
                    if ( block.chunks > 1 && ~'http,abort'.indexOf( type ) &&
                            block.retried < opts.chunkRetry ) {
    
                        block.retried++;
                        tr.send();
    
                    } else {
    
                        // http status 500 ~ 600
                        if ( !flag && type === 'server' ) {
                            type = requestAccept( type );
                        }
    
                        file.setStatus( Status.ERROR, type );
                        owner.trigger( 'uploadError', file, type );
                        owner.trigger( 'uploadComplete', file );
                    }
                });
    
                // 上传成功
                tr.on( 'load', function() {
                    var reason;
    
                    // 如果非预期，转向上传出错。
                    if ( (reason = requestAccept()) ) {
                        tr.trigger( 'error', reason, true );
                        return;
                    }
    
                    // 全部上传完成。
                    if ( file.remaning === 1 ) {
                        me._finishFile( file, ret );
                    } else {
                        tr.destroy();
                    }
                });
    
                // 配置默认的上传字段。
                data = $.extend( data, {
                    id: file.id,
                    name: file.name,
                    type: file.type,
                    lastModifiedDate: file.lastModifiedDate,
                    size: file.size
                });
    
                block.chunks > 1 && $.extend( data, {
                    chunks: block.chunks,
                    chunk: block.chunk
                });
    
                // 在发送之间可以添加字段什么的。。。
                // 如果默认的字段不够使用，可以通过监听此事件来扩展
                owner.trigger( 'uploadBeforeSend', block, data, headers );
    
                // 开始发送。
                tr.appendBlob( opts.fileVal, block.blob, file.name );
                tr.append( data );
                tr.setRequestHeader( headers );
                tr.send();
            },
    
            // 完成上传。
            _finishFile: function( file, ret, hds ) {
                var owner = this.owner;
    
                return owner
                        .request( 'after-send-file', arguments, function() {
                            file.setStatus( Status.COMPLETE );
                            owner.trigger( 'uploadSuccess', file, ret, hds );
                        })
                        .fail(function( reason ) {
    
                            // 如果外部已经标记为invalid什么的，不再改状态。
                            if ( file.getStatus() === Status.PROGRESS ) {
                                file.setStatus( Status.ERROR, reason );
                            }
    
                            owner.trigger( 'uploadError', file, reason );
                        })
                        .always(function() {
                            owner.trigger( 'uploadComplete', file );
                        });
            }
    
        });
    });
    /**
     * @fileOverview 各种验证，包括文件总大小是否超出、单文件是否超出和文件是否重复。
     */
    
    define('widgets/validator',[
        'base',
        'uploader',
        'file',
        'widgets/widget'
    ], function( Base, Uploader, WUFile ) {
    
        var $ = Base.$,
            validators = {},
            api;
    
        /**
         * @event error
         * @param {String} type 错误类型。
         * @description 当validate不通过时，会以派送错误事件的形式通知调用者。通过`upload.on('error', handler)`可以捕获到此类错误，目前有以下错误会在特定的情况下派送错来。
         *
         * * `Q_EXCEED_NUM_LIMIT` 在设置了`fileNumLimit`且尝试给`uploader`添加的文件数量超出这个值时派送。
         * * `Q_EXCEED_SIZE_LIMIT` 在设置了`Q_EXCEED_SIZE_LIMIT`且尝试给`uploader`添加的文件总大小超出这个值时派送。
         * @for  Uploader
         */
    
        // 暴露给外面的api
        api = {
    
            // 添加验证器
            addValidator: function( type, cb ) {
                validators[ type ] = cb;
            },
    
            // 移除验证器
            removeValidator: function( type ) {
                delete validators[ type ];
            }
        };
    
        // 在Uploader初始化的时候启动Validators的初始化
        Uploader.register({
            init: function() {
                var me = this;
                $.each( validators, function() {
                    this.call( me.owner );
                });
            }
        });
    
        /**
         * @property {int} [fileNumLimit=undefined]
         * @namespace options
         * @for Uploader
         * @description 验证文件总数量, 超出则不允许加入队列。
         */
        api.addValidator( 'fileNumLimit', function() {
            var uploader = this,
                opts = uploader.options,
                count = 0,
                max = opts.fileNumLimit >> 0,
                flag = true;
    
            if ( !max ) {
                return;
            }
    
            uploader.on( 'beforeFileQueued', function( file ) {
    
                if ( count >= max && flag ) {
                    flag = false;
                    this.trigger( 'error', 'Q_EXCEED_NUM_LIMIT', max, file );
                    setTimeout(function() {
                        flag = true;
                    }, 1 );
                }
    
                return count >= max ? false : true;
            });
    
            uploader.on( 'fileQueued', function() {
                count++;
            });
    
            uploader.on( 'fileDequeued', function() {
                count--;
            });
    
            uploader.on( 'uploadFinished', function() {
                count = 0;
            });
        });
    
    
        /**
         * @property {int} [fileSizeLimit=undefined]
         * @namespace options
         * @for Uploader
         * @description 验证文件总大小是否超出限制, 超出则不允许加入队列。
         */
        api.addValidator( 'fileSizeLimit', function() {
            var uploader = this,
                opts = uploader.options,
                count = 0,
                max = opts.fileSizeLimit >> 0,
                flag = true;
    
            if ( !max ) {
                return;
            }
    
            uploader.on( 'beforeFileQueued', function( file ) {
                var invalid = count + file.size > max;
    
                if ( invalid && flag ) {
                    flag = false;
                    this.trigger( 'error', 'Q_EXCEED_SIZE_LIMIT', max, file );
                    setTimeout(function() {
                        flag = true;
                    }, 1 );
                }
    
                return invalid ? false : true;
            });
    
            uploader.on( 'fileQueued', function( file ) {
                count += file.size;
            });
    
            uploader.on( 'fileDequeued', function( file ) {
                count -= file.size;
            });
    
            uploader.on( 'uploadFinished', function() {
                count = 0;
            });
        });
    
        /**
         * @property {int} [fileSingleSizeLimit=undefined]
         * @namespace options
         * @for Uploader
         * @description 验证单个文件大小是否超出限制, 超出则不允许加入队列。
         */
        api.addValidator( 'fileSingleSizeLimit', function() {
            var uploader = this,
                opts = uploader.options,
                max = opts.fileSingleSizeLimit;
    
            if ( !max ) {
                return;
            }
    
            uploader.on( 'beforeFileQueued', function( file ) {
    
                if ( file.size > max ) {
                    file.setStatus( WUFile.Status.INVALID, 'exceed_size' );
                    this.trigger( 'error', 'F_EXCEED_SIZE', file );
                    return false;
                }
    
            });
    
        });
    
        /**
         * @property {int} [duplicate=undefined]
         * @namespace options
         * @for Uploader
         * @description 去重， 根据文件名字、文件大小和最后修改时间来生成hash Key.
         */
        api.addValidator( 'duplicate', function() {
            var uploader = this,
                opts = uploader.options,
                mapping = {};
    
            if ( opts.duplicate ) {
                return;
            }
    
            function hashString( str ) {
                var hash = 0,
                    i = 0,
                    len = str.length,
                    _char;
    
                for ( ; i < len; i++ ) {
                    _char = str.charCodeAt( i );
                    hash = _char + (hash << 6) + (hash << 16) - hash;
                }
    
                return hash;
            }
    
            uploader.on( 'beforeFileQueued', function( file ) {
                var hash = file.__hash || (file.__hash = hashString( file.name +
                        file.size + file.lastModifiedDate ));
    
                // 已经重复了
                if ( mapping[ hash ] ) {
                    this.trigger( 'error', 'F_DUPLICATE', file );
                    return false;
                }
            });
    
            uploader.on( 'fileQueued', function( file ) {
                var hash = file.__hash;
    
                hash && (mapping[ hash ] = true);
            });
    
            uploader.on( 'fileDequeued', function( file ) {
                var hash = file.__hash;
    
                hash && (delete mapping[ hash ]);
            });
        });
    
        return api;
    });
    
    /**
     * @fileOverview Runtime管理器，负责Runtime的选择, 连接
     */
    define('runtime/compbase',[],function() {
    
        function CompBase( owner, runtime ) {
    
            this.owner = owner;
            this.options = owner.options;
    
            this.getRuntime = function() {
                return runtime;
            };
    
            this.getRuid = function() {
                return runtime.uid;
            };
    
            this.trigger = function() {
                return owner.trigger.apply( owner, arguments );
            };
        }
    
        return CompBase;
    });
    /**
     * @fileOverview Html5Runtime
     */
    define('runtime/html5/runtime',[
        'base',
        'runtime/runtime',
        'runtime/compbase'
    ], function( Base, Runtime, CompBase ) {
    
        var type = 'html5',
            components = {};
    
        function Html5Runtime() {
            var pool = {},
                me = this,
                destory = this.destory;
    
            Runtime.apply( me, arguments );
            me.type = type;
    
    
            // 这个方法的调用者，实际上是RuntimeClient
            me.exec = function( comp, fn/*, args...*/) {
                var client = this,
                    uid = client.uid,
                    args = Base.slice( arguments, 2 ),
                    instance;
    
                if ( components[ comp ] ) {
                    instance = pool[ uid ] = pool[ uid ] ||
                            new components[ comp ]( client, me );
    
                    if ( instance[ fn ] ) {
                        return instance[ fn ].apply( instance, args );
                    }
                }
            };
    
            me.destory = function() {
                // @todo 删除池子中的所有实例
                return destory && destory.apply( this, arguments );
            };
        }
    
        Base.inherits( Runtime, {
            constructor: Html5Runtime,
    
            // 不需要连接其他程序，直接执行callback
            init: function() {
                var me = this;
                setTimeout(function() {
                    me.trigger('ready');
                }, 1 );
            }
    
        });
    
        // 注册Components
        Html5Runtime.register = function( name, component ) {
            var klass = components[ name ] = Base.inherits( CompBase, component );
            return klass;
        };
    
        // 注册html5运行时。
        // 只有在支持的前提下注册。
        if ( window.Blob && window.FileReader && window.DataView ) {
            Runtime.addRuntime( type, Html5Runtime );
        }
    
        return Html5Runtime;
    });
    /**
     * @fileOverview Blob Html实现
     */
    define('runtime/html5/blob',[
        'runtime/html5/runtime',
        'lib/blob'
    ], function( Html5Runtime, Blob ) {
    
        return Html5Runtime.register( 'Blob', {
            slice: function( start, end ) {
                var blob = this.owner.source,
                    slice = blob.slice || blob.webkitSlice || blob.mozSlice;
    
                blob = slice.call( blob, start, end );
    
                return new Blob( this.getRuid(), blob );
            }
        });
    });
    /**
     * @fileOverview FilePaste
     */
    define('runtime/html5/dnd',[
        'base',
        'runtime/html5/runtime',
        'lib/file'
    ], function( Base, Html5Runtime, File ) {
    
        var $ = Base.$,
            prefix = 'webuploader-dnd-';
    
        return Html5Runtime.register( 'DragAndDrop', {
            init: function() {
                var elem = this.elem = this.options.container;
    
                this.dragEnterHandler = Base.bindFn( this._dragEnterHandler, this );
                this.dragOverHandler = Base.bindFn( this._dragOverHandler, this );
                this.dragLeaveHandler = Base.bindFn( this._dragLeaveHandler, this );
                this.dropHandler = Base.bindFn( this._dropHandler, this );
                this.dndOver = false;
    
                elem.on( 'dragenter', this.dragEnterHandler );
                elem.on( 'dragover', this.dragOverHandler );
                elem.on( 'dragleave', this.dragLeaveHandler );
                elem.on( 'drop', this.dropHandler );
    
                if ( this.options.disableGlobalDnd ) {
                    $( document ).on( 'dragover', this.dragOverHandler );
                    $( document ).on( 'drop', this.dropHandler );
                }
            },
    
            _dragEnterHandler: function( e ) {
                var me = this,
                    denied = me._denied || false,
                    items;
    
                e = e.originalEvent || e;
    
                if ( !me.dndOver ) {
                    me.dndOver = true;
    
                    // 注意只有 chrome 支持。
                    items = e.dataTransfer.items;
    
                    if ( items && items.length ) {
                        me._denied = denied = !me.trigger( 'accept', items );
                    }
    
                    me.elem.addClass( prefix + 'over' );
                    me.elem[ denied ? 'addClass' :
                            'removeClass' ]( prefix + 'denied' );
                }
    
    
                e.dataTransfer.dropEffect = denied ? 'none' : 'copy';
    
                return false;
            },
    
            _dragOverHandler: function( e ) {
                // 只处理框内的。
                var parentElem = this.elem.parent().get( 0 );
                if ( parentElem && !$.contains( parentElem, e.currentTarget ) ) {
                    return false;
                }
    
                clearTimeout( this._leaveTimer );
                this._dragEnterHandler.call( this, e );
    
                return false;
            },
    
            _dragLeaveHandler: function() {
                var me = this,
                    handler;
    
                handler = function() {
                    me.dndOver = false;
                    me.elem.removeClass( prefix + 'over ' + prefix + 'denied' );
                };
    
                clearTimeout( me._leaveTimer );
                me._leaveTimer = setTimeout( handler, 100 );
                return false;
            },
    
            _dropHandler: function( e ) {
                var me = this,
                    ruid = me.getRuid(),
                    parentElem = me.elem.parent().get( 0 );
    
                // 只处理框内的。
                if ( parentElem && !$.contains( parentElem, e.currentTarget ) ) {
                    return false;
                }
    
                me._getTansferFiles( e, function( results ) {
                    me.trigger( 'drop', $.map( results, function( file ) {
                        return new File( ruid, file );
                    }) );
                });
    
                me.dndOver = false;
                me.elem.removeClass( prefix + 'over' );
                return false;
            },
    
            // 如果传入 callback 则去查看文件夹，否则只管当前文件夹。
            _getTansferFiles: function( e, callback ) {
                var results  = [],
                    promises = [],
                    items, files, dataTransfer, file, item, i, len, canAccessFolder;
    
                e = e.originalEvent || e;
    
                dataTransfer = e.dataTransfer;
                items = dataTransfer.items;
                files = dataTransfer.files;
    
                canAccessFolder = !!(items && items[ 0 ].webkitGetAsEntry);
    
                for ( i = 0, len = files.length; i < len; i++ ) {
                    file = files[ i ];
                    item = items && items[ i ];
    
                    if ( canAccessFolder && item.webkitGetAsEntry().isDirectory ) {
    
                        promises.push( this._traverseDirectoryTree(
                                item.webkitGetAsEntry(), results ) );
                    } else {
                        results.push( file );
                    }
                }
    
                Base.when.apply( Base, promises ).done(function() {
    
                    if ( !results.length ) {
                        return;
                    }
    
                    callback( results );
                });
            },
    
            _traverseDirectoryTree: function( entry, results ) {
                var deferred = Base.Deferred(),
                    me = this;
    
                if ( entry.isFile ) {
                    entry.file(function( file ) {
                        results.push( file );
                        deferred.resolve();
                    });
                } else if ( entry.isDirectory ) {
                    entry.createReader().readEntries(function( entries ) {
                        var len = entries.length,
                            promises = [],
                            arr = [],    // 为了保证顺序。
                            i;
    
                        for ( i = 0; i < len; i++ ) {
                            promises.push( me._traverseDirectoryTree(
                                    entries[ i ], arr ) );
                        }
    
                        Base.when.apply( Base, promises ).then(function() {
                            results.push.apply( results, arr );
                            deferred.resolve();
                        }, deferred.reject );
                    });
                }
    
                return deferred.promise();
            },
    
            destroy: function() {
                var elem = this.elem;
    
                elem.off( 'dragenter', this.dragEnterHandler );
                elem.off( 'dragover', this.dragEnterHandler );
                elem.off( 'dragleave', this.dragLeaveHandler );
                elem.off( 'drop', this.dropHandler );
    
                if ( this.options.disableGlobalDnd ) {
                    $( document ).off( 'dragover', this.dragOverHandler );
                    $( document ).off( 'drop', this.dropHandler );
                }
            }
        });
    });
    
    /**
     * @fileOverview FilePaste
     */
    define('runtime/html5/filepaste',[
        'base',
        'runtime/html5/runtime',
        'lib/file'
    ], function( Base, Html5Runtime, File ) {
    
        return Html5Runtime.register( 'FilePaste', {
            init: function() {
                var opts = this.options,
                    elem = this.elem = opts.container,
                    accept = '.*',
                    arr, i, len, item;
    
                // accetp的mimeTypes中生成匹配正则。
                if ( opts.accept ) {
                    arr = [];
    
                    for ( i = 0, len = opts.accept.length; i < len; i++ ) {
                        item = opts.accept[ i ].mimeTypes;
                        item && arr.push( item );
                    }
    
                    if ( arr.length ) {
                        accept = arr.join(',');
                        accept = accept.replace( /,/g, '|' ).replace( /\*/g, '.*' );
                    }
                }
                this.accept = accept = new RegExp( accept, 'i' );
                this.hander = Base.bindFn( this._pasteHander, this );
                elem.on( 'paste', this.hander );
            },
    
            _pasteHander: function( e ) {
                var allowed = [],
                    ruid = this.getRuid(),
                    items, item, blob, i, len;
    
                e = e.originalEvent || e;
                items = e.clipboardData.items;
    
                for ( i = 0, len = items.length; i < len; i++ ) {
                    item = items[ i ];
    
                    if ( item.kind !== 'file' || !(blob = item.getAsFile()) ) {
                        continue;
                    }
    
                    allowed.push( new File( ruid, blob ) );
                }
    
                if ( allowed.length ) {
                    // 不阻止非文件粘贴（文字粘贴）的事件冒泡
                    e.preventDefault();
                    e.stopPropagation();
                    this.trigger( 'paste', allowed );
                }
            },
    
            destroy: function() {
                this.elem.off( 'paste', this.hander );
            }
        });
    });
    
    /**
     * @fileOverview FilePicker
     */
    define('runtime/html5/filepicker',[
        'base',
        'runtime/html5/runtime'
    ], function( Base, Html5Runtime ) {
    
        var $ = Base.$;
    
        return Html5Runtime.register( 'FilePicker', {
            init: function() {
                var container = this.getRuntime().getContainer(),
                    me = this,
                    owner = me.owner,
                    opts = me.options,
                    lable = $( document.createElement('label') ),
                    input = $( document.createElement('input') ),
                    arr, i, len, mouseHandler;
    
                input.attr( 'type', 'file' );
                input.attr( 'name', opts.name );
                input.addClass('webuploader-element-invisible');
    
                lable.on( 'click', function() {
                    input.trigger('click');
                });
    
                lable.css({
                    opacity: 0,
                    width: '100%',
                    height: '100%',
                    display: 'block',
                    cursor: 'pointer',
                    background: '#ffffff'
                });
    
                if ( opts.multiple ) {
                    input.attr( 'multiple', 'multiple' );
                }
    
                // @todo Firefox不支持单独指定后缀
                if ( opts.accept && opts.accept.length > 0 ) {
                    arr = [];
    
                    for ( i = 0, len = opts.accept.length; i < len; i++ ) {
                        arr.push( opts.accept[ i ].mimeTypes );
                    }
    
                    input.attr( 'accept', arr.join(',') );
                }
    
                container.append( input );
                container.append( lable );
    
                mouseHandler = function( e ) {
                    owner.trigger( e.type );
                };
    
                input.on( 'change', function( e ) {
                    var fn = arguments.callee,
                        clone;
    
                    me.files = e.target.files;
    
                    // reset input
                    clone = this.cloneNode( true );
                    this.parentNode.replaceChild( clone, this );
    
                    input.off();
                    input = $( clone ).on( 'change', fn )
                            .on( 'mouseenter mouseleave', mouseHandler );
    
                    owner.trigger('change');
                });
    
                lable.on( 'mouseenter mouseleave', mouseHandler );
    
            },
    
    
            getFiles: function() {
                return this.files;
            },
    
            destroy: function() {
                // todo
            }
        });
    });
    /**
     * @fileOverview Transport
     * @todo 支持chunked传输，优势：
     * 可以将大文件分成小块，挨个传输，可以提高大文件成功率，当失败的时候，也只需要重传那小部分，
     * 而不需要重头再传一次。另外断点续传也需要用chunked方式。
     */
    define('runtime/html5/transport',[
        'base',
        'runtime/html5/runtime'
    ], function( Base, Html5Runtime ) {
    
        var noop = Base.noop,
            $ = Base.$;
    
        return Html5Runtime.register( 'Transport', {
            init: function() {
                this._status = 0;
                this._response = null;
            },
    
            send: function() {
                var owner = this.owner,
                    opts = this.options,
                    xhr = this._initAjax(),
                    blob = owner._blob,
                    server = opts.server,
                    formData, binary, fr;
    
                if ( opts.sendAsBinary ) {
                    server += (/\?/.test( server ) ? '&' : '?') +
                            $.param( owner._formData );
    
                    binary = blob.getSource();
                } else {
                    formData = new FormData();
                    $.each( owner._formData, function( k, v ) {
                        formData.append( k, v );
                    });
    
                    formData.append( opts.fileVal, blob.getSource(),
                            opts.filename || owner._formData.name || '' );
                }
    
                if ( opts.withCredentials && 'withCredentials' in xhr ) {
                    xhr.open( opts.method, server, true );
                    xhr.withCredentials = true;
                } else {
                    xhr.open( opts.method, server );
                }
    
                this._setRequestHeader( xhr, opts.headers );
    
                if ( binary ) {
                    xhr.overrideMimeType('application/octet-stream');
    
                    // android直接发送blob会导致服务端接收到的是空文件。
                    // bug详情。
                    // https://code.google.com/p/android/issues/detail?id=39882
                    // 所以先用fileReader读取出来再通过arraybuffer的方式发送。
                    if ( Base.os.android ) {
                        fr = new FileReader();
    
                        fr.onload = function() {
                            xhr.send( this.result );
                            fr = fr.onload = null;
                        };
    
                        fr.readAsArrayBuffer( binary );
                    } else {
                        xhr.send( binary );
                    }
                } else {
                    xhr.send( formData );
                }
            },
    
            getResponse: function() {
                return this._response;
            },
    
            getResponseAsJson: function() {
                return this._parseJson( this._response );
            },
    
            getStatus: function() {
                return this._status;
            },
    
            abort: function() {
                var xhr = this._xhr;
    
                if ( xhr ) {
                    xhr.upload.onprogress = noop;
                    xhr.onreadystatechange = noop;
                    xhr.abort();
    
                    this._xhr = xhr = null;
                }
            },
    
            destroy: function() {
                this.abort();
            },
    
            _initAjax: function() {
                var me = this,
                    xhr = new XMLHttpRequest(),
                    opts = this.options;
    
                if ( opts.withCredentials && !('withCredentials' in xhr) &&
                        typeof XDomainRequest !== 'undefined' ) {
                    xhr = new XDomainRequest();
                }
    
                xhr.upload.onprogress = function( e ) {
                    var percentage = 0;
    
                    if ( e.lengthComputable ) {
                        percentage = e.loaded / e.total;
                    }
    
                    return me.trigger( 'progress', percentage );
                };
    
                xhr.onreadystatechange = function() {
    
                    if ( xhr.readyState !== 4 ) {
                        return;
                    }
    
                    xhr.upload.onprogress = noop;
                    xhr.onreadystatechange = noop;
                    me._xhr = null;
                    me._status = xhr.status;
    
                    if ( xhr.status >= 200 && xhr.status < 300 ) {
                        me._response = xhr.responseText;
                        return me.trigger('load');
                    } else if ( xhr.status >= 500 && xhr.status < 600 ) {
                        me._response = xhr.responseText;
                        return me.trigger( 'error', 'server' );
                    }
    
    
                    return me.trigger( 'error', me._status ? 'http' : 'abort' );
                };
    
                me._xhr = xhr;
                return xhr;
            },
    
            _setRequestHeader: function( xhr, headers ) {
                $.each( headers, function( key, val ) {
                    xhr.setRequestHeader( key, val );
                });
            },
    
            _parseJson: function( str ) {
                var json;
    
                try {
                    json = JSON.parse( str );
                } catch ( ex ) {
                    json = {};
                }
    
                return json;
            }
        });
    });
    /**
     * @fileOverview FlashRuntime
     */
    define('runtime/flash/runtime',[
        'base',
        'runtime/runtime',
        'runtime/compbase'
    ], function( Base, Runtime, CompBase ) {
    
        var $ = Base.$,
            type = 'flash',
            components = {};
    
    
        function getFlashVersion() {
            var version;
    
            try {
                version = navigator.plugins[ 'Shockwave Flash' ];
                version = version.description;
            } catch ( ex ) {
                try {
                    version = new ActiveXObject('ShockwaveFlash.ShockwaveFlash')
                            .GetVariable('$version');
                } catch ( ex2 ) {
                    version = '0.0';
                }
            }
            version = version.match( /\d+/g );
            return parseFloat( version[ 0 ] + '.' + version[ 1 ], 10 );
        }
    
        function FlashRuntime() {
            var pool = {},
                clients = {},
                destory = this.destory,
                me = this,
                jsreciver = Base.guid('webuploader_');
    
            Runtime.apply( me, arguments );
            me.type = type;
    
    
            // 这个方法的调用者，实际上是RuntimeClient
            me.exec = function( comp, fn/*, args...*/ ) {
                var client = this,
                    uid = client.uid,
                    args = Base.slice( arguments, 2 ),
                    instance;
    
                clients[ uid ] = client;
    
                if ( components[ comp ] ) {
                    if ( !pool[ uid ] ) {
                        pool[ uid ] = new components[ comp ]( client, me );
                    }
    
                    instance = pool[ uid ];
    
                    if ( instance[ fn ] ) {
                        return instance[ fn ].apply( instance, args );
                    }
                }
    
                return me.flashExec.apply( client, arguments );
            };
    
            function handler( evt, obj ) {
                var type = evt.type || evt,
                    parts, uid;
    
                parts = type.split('::');
                uid = parts[ 0 ];
                type = parts[ 1 ];
    
                // console.log.apply( console, arguments );
    
                if ( type === 'Ready' && uid === me.uid ) {
                    me.trigger('ready');
                } else if ( clients[ uid ] ) {
                    clients[ uid ].trigger( type.toLowerCase(), evt, obj );
                }
    
                // Base.log( evt, obj );
            }
    
            // flash的接受器。
            window[ jsreciver ] = function() {
                var args = arguments;
    
                // 为了能捕获得到。
                setTimeout(function() {
                    handler.apply( null, args );
                }, 1 );
            };
    
            this.jsreciver = jsreciver;
    
            this.destory = function() {
                // @todo 删除池子中的所有实例
                return destory && destory.apply( this, arguments );
            };
    
            this.flashExec = function( comp, fn ) {
                var flash = me.getFlash(),
                    args = Base.slice( arguments, 2 );
    
                return flash.exec( this.uid, comp, fn, args );
            };
    
            // @todo
        }
    
        Base.inherits( Runtime, {
            constructor: FlashRuntime,
    
            init: function() {
                var container = this.getContainer(),
                    opts = this.options,
                    html;
    
                // if not the minimal height, shims are not initialized
                // in older browsers (e.g FF3.6, IE6,7,8, Safari 4.0,5.0, etc)
                container.css({
                    position: 'absolute',
                    top: '-8px',
                    left: '-8px',
                    width: '9px',
                    height: '9px',
                    overflow: 'hidden'
                });
    
                // insert flash object
                html = '<object id="' + this.uid + '" type="application/' +
                        'x-shockwave-flash" data="' +  opts.swf + '" ';
    
                if ( Base.browser.ie ) {
                    html += 'classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" ';
                }
    
                html += 'width="100%" height="100%" style="outline:0">'  +
                    '<param name="movie" value="' + opts.swf + '" />' +
                    '<param name="flashvars" value="uid=' + this.uid +
                    '&jsreciver=' + this.jsreciver + '" />' +
                    '<param name="wmode" value="transparent" />' +
                    '<param name="allowscriptaccess" value="always" />' +
                '</object>';
    
                container.html( html );
            },
    
            getFlash: function() {
                if ( this._flash ) {
                    return this._flash;
                }
    
                this._flash = $( '#' + this.uid ).get( 0 );
                return this._flash;
            }
    
        });
    
        FlashRuntime.register = function( name, component ) {
            component = components[ name ] = Base.inherits( CompBase, $.extend({
    
                // @todo fix this later
                flashExec: function() {
                    var owner = this.owner,
                        runtime = this.getRuntime();
    
                    return runtime.flashExec.apply( owner, arguments );
                }
            }, component ) );
    
            return component;
        };
    
        if ( getFlashVersion() >= 11.4 ) {
            Runtime.addRuntime( type, FlashRuntime );
        }
    
        return FlashRuntime;
    });
    /**
     * @fileOverview FilePicker
     */
    define('runtime/flash/filepicker',[
        'base',
        'runtime/flash/runtime'
    ], function( Base, FlashRuntime ) {
        var $ = Base.$;
    
        return FlashRuntime.register( 'FilePicker', {
            init: function( opts ) {
                var copy = $.extend({}, opts ),
                    len, i;
    
                // 修复Flash再没有设置title的情况下无法弹出flash文件选择框的bug.
                len = copy.accept && copy.accept.length;
                for (  i = 0; i < len; i++ ) {
                    if ( !copy.accept[ i ].title ) {
                        copy.accept[ i ].title = 'Files';
                    }
                }
    
                delete copy.button;
                delete copy.container;
    
                this.flashExec( 'FilePicker', 'init', copy );
            },
    
            destroy: function() {
                // todo
            }
        });
    });
    /**
     * @fileOverview  Transport flash实现
     */
    define('runtime/flash/transport',[
        'base',
        'runtime/flash/runtime',
        'runtime/client'
    ], function( Base, FlashRuntime, RuntimeClient ) {
        var $ = Base.$;
    
        return FlashRuntime.register( 'Transport', {
            init: function() {
                this._status = 0;
                this._response = null;
                this._responseJson = null;
            },
    
            send: function() {
                var owner = this.owner,
                    opts = this.options,
                    xhr = this._initAjax(),
                    blob = owner._blob,
                    server = opts.server,
                    binary;
    
                xhr.connectRuntime( blob.ruid );
    
                if ( opts.sendAsBinary ) {
                    server += (/\?/.test( server ) ? '&' : '?') +
                            $.param( owner._formData );
    
                    binary = blob.uid;
                } else {
                    $.each( owner._formData, function( k, v ) {
                        xhr.exec( 'append', k, v );
                    });
    
                    xhr.exec( 'appendBlob', opts.fileVal, blob.uid,
                            opts.filename || owner._formData.name || '' );
                }
    
                this._setRequestHeader( xhr, opts.headers );
                xhr.exec( 'send', {
                    method: opts.method,
                    url: server
                }, binary );
            },
    
            getStatus: function() {
                return this._status;
            },
    
            getResponse: function() {
                return this._response;
            },
    
            getResponseAsJson: function() {
                return this._responseJson;
            },
    
            abort: function() {
                var xhr = this._xhr;
    
                if ( xhr ) {
                    xhr.exec('abort');
                    xhr.destroy();
                    this._xhr = xhr = null;
                }
            },
    
            destroy: function() {
                this.abort();
            },
    
            _initAjax: function() {
                var me = this,
                    xhr = new RuntimeClient('XMLHttpRequest');
    
                xhr.on( 'uploadprogress progress', function( e ) {
                    return me.trigger( 'progress', e.loaded / e.total );
                });
    
                xhr.on( 'load', function() {
                    var status = xhr.exec('getStatus'),
                        err = '';
    
                    xhr.off();
                    me._xhr = null;
    
                    if ( status >= 200 && status < 300 ) {
                        me._response = xhr.exec('getResponse');
                        me._responseJson = xhr.exec('getResponseAsJson');
                    } else if ( status >= 500 && status < 600 ) {
                        me._response = xhr.exec('getResponse');
                        me._responseJson = xhr.exec('getResponseAsJson');
                        err = 'server';
                    } else {
                        err = 'http';
                    }
    
                    xhr.destroy();
                    xhr = null;
    
                    return err ? me.trigger( 'error', err ) : me.trigger('load');
                });
    
                xhr.on( 'error', function() {
                    xhr.off();
                    me._xhr = null;
                    me.trigger( 'error', 'http' );
                });
    
                me._xhr = xhr;
                return xhr;
            },
    
            _setRequestHeader: function( xhr, headers ) {
                $.each( headers, function( key, val ) {
                    xhr.exec( 'setRequestHeader', key, val );
                });
            }
        });
    });
    /**
     * @fileOverview 没有图像处理的版本。
     */
    define('preset/withoutimage',[
        'base',
    
        // widgets
        'widgets/filednd',
        'widgets/filepaste',
        'widgets/filepicker',
        'widgets/queue',
        'widgets/runtime',
        'widgets/upload',
        'widgets/validator',
    
        // runtimes
        // html5
        'runtime/html5/blob',
        'runtime/html5/dnd',
        'runtime/html5/filepaste',
        'runtime/html5/filepicker',
        'runtime/html5/transport',
    
        // flash
        'runtime/flash/filepicker',
        'runtime/flash/transport'
    ], function( Base ) {
        return Base;
    });
    define('webuploader',[
        'preset/withoutimage'
    ], function( preset ) {
        return preset;
    });
    return require('webuploader');
});
/*! WebUploader 0.1.2 */





/**

 * @fileOverview 让内部各个部件的代码可以用[amd](https://github.com/amdjs/amdjs-api/wiki/AMD)模块定义方式组织起来。

 *

 * AMD API 内部的简单不完全实现，请忽略。只有当WebUploader被合并成一个文件的时候才会引入。

 */

(function( root, factory ) {

    var modules = {},



        // 内部require, 简单不完全实现。

        // https://github.com/amdjs/amdjs-api/wiki/require

        _require = function( deps, callback ) {

            var args, len, i;



            // 如果deps不是数组，则直接返回指定module

            if ( typeof deps === 'string' ) {

                return getModule( deps );

            } else {

                args = [];

                for( len = deps.length, i = 0; i < len; i++ ) {

                    args.push( getModule( deps[ i ] ) );

                }



                return callback.apply( null, args );

            }

        },



        // 内部define，暂时不支持不指定id.

        _define = function( id, deps, factory ) {

            if ( arguments.length === 2 ) {

                factory = deps;

                deps = null;

            }



            _require( deps || [], function() {

                setModule( id, factory, arguments );

            });

        },



        // 设置module, 兼容CommonJs写法。

        setModule = function( id, factory, args ) {

            var module = {

                    exports: factory

                },

                returned;



            if ( typeof factory === 'function' ) {

                args.length || (args = [ _require, module.exports, module ]);

                returned = factory.apply( null, args );

                returned !== undefined && (module.exports = returned);

            }



            modules[ id ] = module.exports;

        },



        // 根据id获取module

        getModule = function( id ) {

            var module = modules[ id ] || root[ id ];



            if ( !module ) {

                throw new Error( '`' + id + '` is undefined' );

            }



            return module;

        },



        // 将所有modules，将路径ids装换成对象。

        exportsTo = function( obj ) {

            var key, host, parts, part, last, ucFirst;



            // make the first character upper case.

            ucFirst = function( str ) {

                return str && (str.charAt( 0 ).toUpperCase() + str.substr( 1 ));

            };



            for ( key in modules ) {

                host = obj;



                if ( !modules.hasOwnProperty( key ) ) {

                    continue;

                }



                parts = key.split('/');

                last = ucFirst( parts.pop() );



                while( (part = ucFirst( parts.shift() )) ) {

                    host[ part ] = host[ part ] || {};

                    host = host[ part ];

                }



                host[ last ] = modules[ key ];

            }

        },



        exports = factory( root, _define, _require ),

        origin;



    // exports every module.

    exportsTo( exports );



    if ( typeof module === 'object' && typeof module.exports === 'object' ) {



        // For CommonJS and CommonJS-like environments where a proper window is present,

        module.exports = exports;

    } else if ( typeof define === 'function' && define.amd ) {



        // Allow using this built library as an AMD module

        // in another project. That other project will only

        // see this AMD call, not the internal modules in

        // the closure below.

        define([], exports );

    } else {



        // Browser globals case. Just assign the

        // result to a property on the global.

        origin = root.WebUploader;

        root.WebUploader = exports;

        root.WebUploader.noConflict = function() {

            root.WebUploader = origin;

        };

    }

})( this, function( window, define, require ) {





    /**

     * @fileOverview jQuery or Zepto

     */

    define('dollar-third',[],function() {

        return window.jQuery || window.Zepto;

    });

    /**

     * @fileOverview Dom 操作相关

     */

    define('dollar',[

        'dollar-third'

    ], function( _ ) {

        return _;

    });

    /**

     * @fileOverview 使用jQuery的Promise

     */

    define('promise-third',[

        'dollar'

    ], function( $ ) {

        return {

            Deferred: $.Deferred,

            when: $.when,

    
            isPromise: function( anything ) {

                return anything && typeof anything.then === 'function';

            }

        };

    });

    /**

     * @fileOverview Promise/A+

     */

    define('promise',[

        'promise-third'

    ], function( _ ) {

        return _;

    });

    /**

     * @fileOverview 基础类方法。

     */

    
    /**

     * Web Uploader内部类的详细说明，以下提及的功能类，都可以在`WebUploader`这个变量中访问到。

     *

     * As you know, Web Uploader的每个文件都是用过[AMD](https://github.com/amdjs/amdjs-api/wiki/AMD)规范中的`define`组织起来的, 每个Module都会有个module id.

     * 默认module id该文件的路径，而此路径将会转化成名字空间存放在WebUploader中。如：

     *

     * * module `base`：WebUploader.Base

     * * module `file`: WebUploader.File

     * * module `lib/dnd`: WebUploader.Lib.Dnd

     * * module `runtime/html5/dnd`: WebUploader.Runtime.Html5.Dnd

     *

     *

     * 以下文档将可能省略`WebUploader`前缀。

     * @module WebUploader

     * @title WebUploader API文档

     */

    define('base',[

        'dollar',

        'promise'

    ], function( $, promise ) {

    
        var noop = function() {},

            call = Function.call;

    
        // http://jsperf.com/uncurrythis

        // 反科里化

        function uncurryThis( fn ) {

            return function() {

                return call.apply( fn, arguments );

            };

        }

    
        function bindFn( fn, context ) {

            return function() {

                return fn.apply( context, arguments );

            };

        }

    
        function createObject( proto ) {

            var f;

    
            if ( Object.create ) {

                return Object.create( proto );

            } else {

                f = function() {};

                f.prototype = proto;

                return new f();

            }

        }

    
    
        /**

         * 基础类，提供一些简单常用的方法。

         * @class Base

         */

        return {

    
            /**

             * @property {String} version 当前版本号。

             */

            version: '0.1.2',

    
            /**

             * @property {jQuery|Zepto} $ 引用依赖的jQuery或者Zepto对象。

             */

            $: $,

    
            Deferred: promise.Deferred,

    
            isPromise: promise.isPromise,

    
            when: promise.when,

    
            /**

             * @description  简单的浏览器检查结果。

             *

             * * `webkit`  webkit版本号，如果浏览器为非webkit内核，此属性为`undefined`。

             * * `chrome`  chrome浏览器版本号，如果浏览器为chrome，此属性为`undefined`。

             * * `ie`  ie浏览器版本号，如果浏览器为非ie，此属性为`undefined`。**暂不支持ie10+**

             * * `firefox`  firefox浏览器版本号，如果浏览器为非firefox，此属性为`undefined`。

             * * `safari`  safari浏览器版本号，如果浏览器为非safari，此属性为`undefined`。

             * * `opera`  opera浏览器版本号，如果浏览器为非opera，此属性为`undefined`。

             *

             * @property {Object} [browser]

             */

            browser: (function( ua ) {

                var ret = {},

                    webkit = ua.match( /WebKit\/([\d.]+)/ ),

                    chrome = ua.match( /Chrome\/([\d.]+)/ ) ||

                        ua.match( /CriOS\/([\d.]+)/ ),

    
                    ie = ua.match( /MSIE\s([\d\.]+)/ ) ||

                        ua.match(/(?:trident)(?:.*rv:([\w.]+))?/i),

                    firefox = ua.match( /Firefox\/([\d.]+)/ ),

                    safari = ua.match( /Safari\/([\d.]+)/ ),

                    opera = ua.match( /OPR\/([\d.]+)/ );

    
                webkit && (ret.webkit = parseFloat( webkit[ 1 ] ));

                chrome && (ret.chrome = parseFloat( chrome[ 1 ] ));

                ie && (ret.ie = parseFloat( ie[ 1 ] ));

                firefox && (ret.firefox = parseFloat( firefox[ 1 ] ));

                safari && (ret.safari = parseFloat( safari[ 1 ] ));

                opera && (ret.opera = parseFloat( opera[ 1 ] ));

    
                return ret;

            })( navigator.userAgent ),

    
            /**

             * @description  操作系统检查结果。

             *

             * * `android`  如果在android浏览器环境下，此值为对应的android版本号，否则为`undefined`。

             * * `ios` 如果在ios浏览器环境下，此值为对应的ios版本号，否则为`undefined`。

             * @property {Object} [os]

             */

            os: (function( ua ) {

                var ret = {},

    
                    // osx = !!ua.match( /\(Macintosh\; Intel / ),

                    android = ua.match( /(?:Android);?[\s\/]+([\d.]+)?/ ),

                    ios = ua.match( /(?:iPad|iPod|iPhone).*OS\s([\d_]+)/ );

    
                // osx && (ret.osx = true);

                android && (ret.android = parseFloat( android[ 1 ] ));

                ios && (ret.ios = parseFloat( ios[ 1 ].replace( /_/g, '.' ) ));

    
                return ret;

            })( navigator.userAgent ),

    
            /**

             * 实现类与类之间的继承。

             * @method inherits

             * @grammar Base.inherits( super ) => child

             * @grammar Base.inherits( super, protos ) => child

             * @grammar Base.inherits( super, protos, statics ) => child

             * @param  {Class} super 父类

             * @param  {Object | Function} [protos] 子类或者对象。如果对象中包含constructor，子类将是用此属性值。

             * @param  {Function} [protos.constructor] 子类构造器，不指定的话将创建个临时的直接执行父类构造器的方法。

             * @param  {Object} [statics] 静态属性或方法。

             * @return {Class} 返回子类。

             * @example

             * function Person() {

             *     console.log( 'Super' );

             * }

             * Person.prototype.hello = function() {

             *     console.log( 'hello' );

             * };

             *

             * var Manager = Base.inherits( Person, {

             *     world: function() {

             *         console.log( 'World' );

             *     }

             * });

             *

             * // 因为没有指定构造器，父类的构造器将会执行。

             * var instance = new Manager();    // => Super

             *

             * // 继承子父类的方法

             * instance.hello();    // => hello

             * instance.world();    // => World

             *

             * // 子类的__super__属性指向父类

             * console.log( Manager.__super__ === Person );    // => true

             */

            inherits: function( Super, protos, staticProtos ) {

                var child;

    
                if ( typeof protos === 'function' ) {

                    child = protos;

                    protos = null;

                } else if ( protos && protos.hasOwnProperty('constructor') ) {

                    child = protos.constructor;

                } else {

                    child = function() {

                        return Super.apply( this, arguments );

                    };

                }

    
                // 复制静态方法

                $.extend( true, child, Super, staticProtos || {} );

    
                /* jshint camelcase: false */

    
                // 让子类的__super__属性指向父类。

                child.__super__ = Super.prototype;

    
                // 构建原型，添加原型方法或属性。

                // 暂时用Object.create实现。

                child.prototype = createObject( Super.prototype );

                protos && $.extend( true, child.prototype, protos );

    
                return child;

            },

    
            /**

             * 一个不做任何事情的方法。可以用来赋值给默认的callback.

             * @method noop

             */

            noop: noop,

    
            /**

             * 返回一个新的方法，此方法将已指定的`context`来执行。

             * @grammar Base.bindFn( fn, context ) => Function

             * @method bindFn

             * @example

             * var doSomething = function() {

             *         console.log( this.name );

             *     },

             *     obj = {

             *         name: 'Object Name'

             *     },

             *     aliasFn = Base.bind( doSomething, obj );

             *

             *  aliasFn();    // => Object Name

             *

             */

            bindFn: bindFn,

    
            /**

             * 引用Console.log如果存在的话，否则引用一个[空函数loop](#WebUploader:Base.log)。

             * @grammar Base.log( args... ) => undefined

             * @method log

             */

            log: (function() {

                if ( window.console ) {

                    return bindFn( console.log, console );

                }

                return noop;

            })(),

    
            nextTick: (function() {

    
                return function( cb ) {

                    setTimeout( cb, 1 );

                };

    
                // @bug 当浏览器不在当前窗口时就停了。

                // var next = window.requestAnimationFrame ||

                //     window.webkitRequestAnimationFrame ||

                //     window.mozRequestAnimationFrame ||

                //     function( cb ) {

                //         window.setTimeout( cb, 1000 / 60 );

                //     };

    
                // // fix: Uncaught TypeError: Illegal invocation

                // return bindFn( next, window );

            })(),

    
            /**

             * 被[uncurrythis](http://www.2ality.com/2011/11/uncurrying-this.html)的数组slice方法。

             * 将用来将非数组对象转化成数组对象。

             * @grammar Base.slice( target, start[, end] ) => Array

             * @method slice

             * @example

             * function doSomthing() {

             *     var args = Base.slice( arguments, 1 );

             *     console.log( args );

             * }

             *

             * doSomthing( 'ignored', 'arg2', 'arg3' );    // => Array ["arg2", "arg3"]

             */

            slice: uncurryThis( [].slice ),

    
            /**

             * 生成唯一的ID

             * @method guid

             * @grammar Base.guid() => String

             * @grammar Base.guid( prefx ) => String

             */

            guid: (function() {

                var counter = 0;

    
                return function( prefix ) {

                    var guid = (+new Date()).toString( 32 ),

                        i = 0;

    
                    for ( ; i < 5; i++ ) {

                        guid += Math.floor( Math.random() * 65535 ).toString( 32 );

                    }

    
                    return (prefix || 'wu_') + guid + (counter++).toString( 32 );

                };

            })(),

    
            /**

             * 格式化文件大小, 输出成带单位的字符串

             * @method formatSize

             * @grammar Base.formatSize( size ) => String

             * @grammar Base.formatSize( size, pointLength ) => String

             * @grammar Base.formatSize( size, pointLength, units ) => String

             * @param {Number} size 文件大小

             * @param {Number} [pointLength=2] 精确到的小数点数。

             * @param {Array} [units=[ 'B', 'K', 'M', 'G', 'TB' ]] 单位数组。从字节，到千字节，一直往上指定。如果单位数组里面只指定了到了K(千字节)，同时文件大小大于M, 此方法的输出将还是显示成多少K.

             * @example

             * console.log( Base.formatSize( 100 ) );    // => 100B

             * console.log( Base.formatSize( 1024 ) );    // => 1.00K

             * console.log( Base.formatSize( 1024, 0 ) );    // => 1K

             * console.log( Base.formatSize( 1024 * 1024 ) );    // => 1.00M

             * console.log( Base.formatSize( 1024 * 1024 * 1024 ) );    // => 1.00G

             * console.log( Base.formatSize( 1024 * 1024 * 1024, 0, ['B', 'KB', 'MB'] ) );    // => 1024MB

             */

            formatSize: function( size, pointLength, units ) {

                var unit;

    
                units = units || [ 'B', 'K', 'M', 'G', 'TB' ];

    
                while ( (unit = units.shift()) && size > 1024 ) {

                    size = size / 1024;

                }

    
                return (unit === 'B' ? size : size.toFixed( pointLength || 2 )) +

                        unit;

            }

        };

    });

    /**

     * 事件处理类，可以独立使用，也可以扩展给对象使用。

     * @fileOverview Mediator

     */

    define('mediator',[

        'base'

    ], function( Base ) {

        var $ = Base.$,

            slice = [].slice,

            separator = /\s+/,

            protos;

    
        // 根据条件过滤出事件handlers.

        function findHandlers( arr, name, callback, context ) {

            return $.grep( arr, function( handler ) {

                return handler &&

                        (!name || handler.e === name) &&

                        (!callback || handler.cb === callback ||

                        handler.cb._cb === callback) &&

                        (!context || handler.ctx === context);

            });

        }

    
        function eachEvent( events, callback, iterator ) {

            // 不支持对象，只支持多个event用空格隔开

            $.each( (events || '').split( separator ), function( _, key ) {

                iterator( key, callback );

            });

        }

    
        function triggerHanders( events, args ) {

            var stoped = false,

                i = -1,

                len = events.length,

                handler;

    
            while ( ++i < len ) {

                handler = events[ i ];

    
                if ( handler.cb.apply( handler.ctx2, args ) === false ) {

                    stoped = true;

                    break;

                }

            }

    
            return !stoped;

        }

    
        protos = {

    
            /**

             * 绑定事件。

             *

             * `callback`方法在执行时，arguments将会来源于trigger的时候携带的参数。如

             * ```javascript

             * var obj = {};

             *

             * // 使得obj有事件行为

             * Mediator.installTo( obj );

             *

             * obj.on( 'testa', function( arg1, arg2 ) {

             *     console.log( arg1, arg2 ); // => 'arg1', 'arg2'

             * });

             *

             * obj.trigger( 'testa', 'arg1', 'arg2' );

             * ```

             *

             * 如果`callback`中，某一个方法`return false`了，则后续的其他`callback`都不会被执行到。

             * 切会影响到`trigger`方法的返回值，为`false`。

             *

             * `on`还可以用来添加一个特殊事件`all`, 这样所有的事件触发都会响应到。同时此类`callback`中的arguments有一个不同处，

             * 就是第一个参数为`type`，记录当前是什么事件在触发。此类`callback`的优先级比脚低，会再正常`callback`执行完后触发。

             * ```javascript

             * obj.on( 'all', function( type, arg1, arg2 ) {

             *     console.log( type, arg1, arg2 ); // => 'testa', 'arg1', 'arg2'

             * });

             * ```

             *

             * @method on

             * @grammar on( name, callback[, context] ) => self

             * @param  {String}   name     事件名，支持多个事件用空格隔开

             * @param  {Function} callback 事件处理器

             * @param  {Object}   [context]  事件处理器的上下文。

             * @return {self} 返回自身，方便链式

             * @chainable

             * @class Mediator

             */

            on: function( name, callback, context ) {

                var me = this,

                    set;

    
                if ( !callback ) {

                    return this;

                }

    
                set = this._events || (this._events = []);

    
                eachEvent( name, callback, function( name, callback ) {

                    var handler = { e: name };

    
                    handler.cb = callback;

                    handler.ctx = context;

                    handler.ctx2 = context || me;

                    handler.id = set.length;

    
                    set.push( handler );

                });

    
                return this;

            },

    
            /**

             * 绑定事件，且当handler执行完后，自动解除绑定。

             * @method once

             * @grammar once( name, callback[, context] ) => self

             * @param  {String}   name     事件名

             * @param  {Function} callback 事件处理器

             * @param  {Object}   [context]  事件处理器的上下文。

             * @return {self} 返回自身，方便链式

             * @chainable

             */

            once: function( name, callback, context ) {

                var me = this;

    
                if ( !callback ) {

                    return me;

                }

    
                eachEvent( name, callback, function( name, callback ) {

                    var once = function() {

                            me.off( name, once );

                            return callback.apply( context || me, arguments );

                        };

    
                    once._cb = callback;

                    me.on( name, once, context );

                });

    
                return me;

            },

    
            /**

             * 解除事件绑定

             * @method off

             * @grammar off( [name[, callback[, context] ] ] ) => self

             * @param  {String}   [name]     事件名

             * @param  {Function} [callback] 事件处理器

             * @param  {Object}   [context]  事件处理器的上下文。

             * @return {self} 返回自身，方便链式

             * @chainable

             */

            off: function( name, cb, ctx ) {

                var events = this._events;

    
                if ( !events ) {

                    return this;

                }

    
                if ( !name && !cb && !ctx ) {

                    this._events = [];

                    return this;

                }

    
                eachEvent( name, cb, function( name, cb ) {

                    $.each( findHandlers( events, name, cb, ctx ), function() {

                        delete events[ this.id ];

                    });

                });

    
                return this;

            },

    
            /**

             * 触发事件

             * @method trigger

             * @grammar trigger( name[, args...] ) => self

             * @param  {String}   type     事件名

             * @param  {*} [...] 任意参数

             * @return {Boolean} 如果handler中return false了，则返回false, 否则返回true

             */

            trigger: function( type ) {

                var args, events, allEvents;

    
                if ( !this._events || !type ) {

                    return this;

                }

    
                args = slice.call( arguments, 1 );

                events = findHandlers( this._events, type );

                allEvents = findHandlers( this._events, 'all' );

    
                return triggerHanders( events, args ) &&

                        triggerHanders( allEvents, arguments );

            }

        };

    
        /**

         * 中介者，它本身是个单例，但可以通过[installTo](#WebUploader:Mediator:installTo)方法，使任何对象具备事件行为。

         * 主要目的是负责模块与模块之间的合作，降低耦合度。

         *

         * @class Mediator

         */

        return $.extend({

    
            /**

             * 可以通过这个接口，使任何对象具备事件功能。

             * @method installTo

             * @param  {Object} obj 需要具备事件行为的对象。

             * @return {Object} 返回obj.

             */

            installTo: function( obj ) {

                return $.extend( obj, protos );

            }

    
        }, protos );

    });

    /**

     * @fileOverview Uploader上传类

     */

    define('uploader',[

        'base',

        'mediator'

    ], function( Base, Mediator ) {

    
        var $ = Base.$;

    
        /**

         * 上传入口类。

         * @class Uploader

         * @constructor

         * @grammar new Uploader( opts ) => Uploader

         * @example

         * var uploader = WebUploader.Uploader({

         *     swf: 'path_of_swf/Uploader.swf',

         *

         *     // 开起分片上传。

         *     chunked: true

         * });

         */

        function Uploader( opts ) {

            this.options = $.extend( true, {}, Uploader.options, opts );

            this._init( this.options );

        }

    
        // default Options

        // widgets中有相应扩展

        Uploader.options = {};

        Mediator.installTo( Uploader.prototype );

    
        // 批量添加纯命令式方法。

        $.each({

            upload: 'start-upload',

            stop: 'stop-upload',

            getFile: 'get-file',

            getFiles: 'get-files',

            addFile: 'add-file',

            addFiles: 'add-file',

            sort: 'sort-files',

            removeFile: 'remove-file',

            skipFile: 'skip-file',

            retry: 'retry',

            isInProgress: 'is-in-progress',

            makeThumb: 'make-thumb',

            getDimension: 'get-dimension',

            addButton: 'add-btn',

            getRuntimeType: 'get-runtime-type',

            refresh: 'refresh',

            disable: 'disable',

            enable: 'enable',

            reset: 'reset'

        }, function( fn, command ) {

            Uploader.prototype[ fn ] = function() {

                return this.request( command, arguments );

            };

        });

    
        $.extend( Uploader.prototype, {

            state: 'pending',

    
            _init: function( opts ) {

                var me = this;

    
                me.request( 'init', opts, function() {

                    me.state = 'ready';

                    me.trigger('ready');

                });

            },

    
            /**

             * 获取或者设置Uploader配置项。

             * @method option

             * @grammar option( key ) => *

             * @grammar option( key, val ) => self

             * @example

             *

             * // 初始状态图片上传前不会压缩

             * var uploader = new WebUploader.Uploader({

             *     resize: null;

             * });

             *

             * // 修改后图片上传前，尝试将图片压缩到1600 * 1600

             * uploader.options( 'resize', {

             *     width: 1600,

             *     height: 1600

             * });

             */

            option: function( key, val ) {

                var opts = this.options;

    
                // setter

                if ( arguments.length > 1 ) {

    
                    if ( $.isPlainObject( val ) &&

                            $.isPlainObject( opts[ key ] ) ) {

                        $.extend( opts[ key ], val );

                    } else {

                        opts[ key ] = val;

                    }

    
                } else {    // getter

                    return key ? opts[ key ] : opts;

                }

            },

    
            /**

             * 获取文件统计信息。返回一个包含一下信息的对象。

             * * `successNum` 上传成功的文件数

             * * `uploadFailNum` 上传失败的文件数

             * * `cancelNum` 被删除的文件数

             * * `invalidNum` 无效的文件数

             * * `queueNum` 还在队列中的文件数

             * @method getStats

             * @grammar getStats() => Object

             */

            getStats: function() {

                // return this._mgr.getStats.apply( this._mgr, arguments );

                var stats = this.request('get-stats');

    
                return {

                    successNum: stats.numOfSuccess,

    
                    // who care?

                    // queueFailNum: 0,

                    cancelNum: stats.numOfCancel,

                    invalidNum: stats.numOfInvalid,

                    uploadFailNum: stats.numOfUploadFailed,

                    queueNum: stats.numOfQueue

                };

            },

    
            // 需要重写此方法来来支持opts.onEvent和instance.onEvent的处理器

            trigger: function( type/*, args...*/ ) {

                var args = [].slice.call( arguments, 1 ),

                    opts = this.options,

                    name = 'on' + type.substring( 0, 1 ).toUpperCase() +

                        type.substring( 1 );

    
                if (

                        // 调用通过on方法注册的handler.

                        Mediator.trigger.apply( this, arguments ) === false ||

    
                        // 调用opts.onEvent

                        $.isFunction( opts[ name ] ) &&

                        opts[ name ].apply( this, args ) === false ||

    
                        // 调用this.onEvent

                        $.isFunction( this[ name ] ) &&

                        this[ name ].apply( this, args ) === false ||

    
                        // 广播所有uploader的事件。

                        Mediator.trigger.apply( Mediator,

                        [ this, type ].concat( args ) ) === false ) {

    
                    return false;

                }

    
                return true;

            },

    
            // widgets/widget.js将补充此方法的详细文档。

            request: Base.noop

        });

    
        /**

         * 创建Uploader实例，等同于new Uploader( opts );

         * @method create

         * @class Base

         * @static

         * @grammar Base.create( opts ) => Uploader

         */

        Base.create = Uploader.create = function( opts ) {

            return new Uploader( opts );

        };

    
        // 暴露Uploader，可以通过它来扩展业务逻辑。

        Base.Uploader = Uploader;

    
        return Uploader;

    });

    /**

     * @fileOverview Runtime管理器，负责Runtime的选择, 连接

     */

    define('runtime/runtime',[

        'base',

        'mediator'

    ], function( Base, Mediator ) {

    
        var $ = Base.$,

            factories = {},

    
            // 获取对象的第一个key

            getFirstKey = function( obj ) {

                for ( var key in obj ) {

                    if ( obj.hasOwnProperty( key ) ) {

                        return key;

                    }

                }

                return null;

            };

    
        // 接口类。

        function Runtime( options ) {

            this.options = $.extend({

                container: document.body

            }, options );

            this.uid = Base.guid('rt_');

        }

    
        $.extend( Runtime.prototype, {

    
            getContainer: function() {

                var opts = this.options,

                    parent, container;

    
                if ( this._container ) {

                    return this._container;

                }

    
                parent = $( opts.container || document.body );

                container = $( document.createElement('div') );

    
                container.attr( 'id', 'rt_' + this.uid );

                container.css({

                    position: 'absolute',

                    top: '0px',

                    left: '0px',

                    width: '1px',

                    height: '1px',

                    overflow: 'hidden'

                });

    
                parent.append( container );

                parent.addClass('webuploader-container');

                this._container = container;

                return container;

            },

    
            init: Base.noop,

            exec: Base.noop,

    
            destroy: function() {

                if ( this._container ) {

                    this._container.parentNode.removeChild( this.__container );

                }

    
                this.off();

            }

        });

    
        Runtime.orders = 'html5,flash';

    
    
        /**

         * 添加Runtime实现。

         * @param {String} type    类型

         * @param {Runtime} factory 具体Runtime实现。

         */

        Runtime.addRuntime = function( type, factory ) {

            factories[ type ] = factory;

        };

    
        Runtime.hasRuntime = function( type ) {

            return !!(type ? factories[ type ] : getFirstKey( factories ));

        };

    
        Runtime.create = function( opts, orders ) {

            var type, runtime;

    
            orders = orders || Runtime.orders;

            $.each( orders.split( /\s*,\s*/g ), function() {

                if ( factories[ this ] ) {

                    type = this;

                    return false;

                }

            });

    
            type = type || getFirstKey( factories );

    
            if ( !type ) {

                throw new Error('Runtime Error');

            }

    
            runtime = new factories[ type ]( opts );

            return runtime;

        };

    
        Mediator.installTo( Runtime.prototype );

        return Runtime;

    });

    
    /**

     * @fileOverview Runtime管理器，负责Runtime的选择, 连接

     */

    define('runtime/client',[

        'base',

        'mediator',

        'runtime/runtime'

    ], function( Base, Mediator, Runtime ) {

    
        var cache;

    
        cache = (function() {

            var obj = {};

    
            return {

                add: function( runtime ) {

                    obj[ runtime.uid ] = runtime;

                },

    
                get: function( ruid, standalone ) {

                    var i;

    
                    if ( ruid ) {

                        return obj[ ruid ];

                    }

    
                    for ( i in obj ) {

                        // 有些类型不能重用，比如filepicker.

                        if ( standalone && obj[ i ].__standalone ) {

                            continue;

                        }

    
                        return obj[ i ];

                    }

    
                    return null;

                },

    
                remove: function( runtime ) {

                    delete obj[ runtime.uid ];

                }

            };

        })();

    
        function RuntimeClient( component, standalone ) {

            var deferred = Base.Deferred(),

                runtime;

    
            this.uid = Base.guid('client_');

    
            // 允许runtime没有初始化之前，注册一些方法在初始化后执行。

            this.runtimeReady = function( cb ) {

                return deferred.done( cb );

            };

    
            this.connectRuntime = function( opts, cb ) {

    
                // already connected.

                if ( runtime ) {

                    throw new Error('already connected!');

                }

    
                deferred.done( cb );

    
                if ( typeof opts === 'string' && cache.get( opts ) ) {

                    runtime = cache.get( opts );

                }

    
                // 像filePicker只能独立存在，不能公用。

                runtime = runtime || cache.get( null, standalone );

    
                // 需要创建

                if ( !runtime ) {

                    runtime = Runtime.create( opts, opts.runtimeOrder );

                    runtime.__promise = deferred.promise();

                    runtime.once( 'ready', deferred.resolve );

                    runtime.init();

                    cache.add( runtime );

                    runtime.__client = 1;

                } else {

                    // 来自cache

                    Base.$.extend( runtime.options, opts );

                    runtime.__promise.then( deferred.resolve );

                    runtime.__client++;

                }

    
                standalone && (runtime.__standalone = standalone);

                return runtime;

            };

    
            this.getRuntime = function() {

                return runtime;

            };

    
            this.disconnectRuntime = function() {

                if ( !runtime ) {

                    return;

                }

    
                runtime.__client--;

    
                if ( runtime.__client <= 0 ) {

                    cache.remove( runtime );

                    delete runtime.__promise;

                    runtime.destroy();

                }

    
                runtime = null;

            };

    
            this.exec = function() {

                if ( !runtime ) {

                    return;

                }

    
                var args = Base.slice( arguments );

                component && args.unshift( component );

    
                return runtime.exec.apply( this, args );

            };

    
            this.getRuid = function() {

                return runtime && runtime.uid;

            };

    
            this.destroy = (function( destroy ) {

                return function() {

                    destroy && destroy.apply( this, arguments );

                    this.trigger('destroy');

                    this.off();

                    this.exec('destroy');

                    this.disconnectRuntime();

                };

            })( this.destroy );

        }

    
        Mediator.installTo( RuntimeClient.prototype );

        return RuntimeClient;

    });

    /**

     * @fileOverview 错误信息

     */

    define('lib/dnd',[

        'base',

        'mediator',

        'runtime/client'

    ], function( Base, Mediator, RuntimeClent ) {

    
        var $ = Base.$;

    
        function DragAndDrop( opts ) {

            opts = this.options = $.extend({}, DragAndDrop.options, opts );

    
            opts.container = $( opts.container );

    
            if ( !opts.container.length ) {

                return;

            }

    
            RuntimeClent.call( this, 'DragAndDrop' );

        }

    
        DragAndDrop.options = {

            accept: null,

            disableGlobalDnd: false

        };

    
        Base.inherits( RuntimeClent, {

            constructor: DragAndDrop,

    
            init: function() {

                var me = this;

    
                me.connectRuntime( me.options, function() {

                    me.exec('init');

                    me.trigger('ready');

                });

            },

    
            destroy: function() {

                this.disconnectRuntime();

            }

        });

    
        Mediator.installTo( DragAndDrop.prototype );

    
        return DragAndDrop;

    });

    /**

     * @fileOverview 组件基类。

     */

    define('widgets/widget',[

        'base',

        'uploader'

    ], function( Base, Uploader ) {

    
        var $ = Base.$,

            _init = Uploader.prototype._init,

            IGNORE = {},

            widgetClass = [];

    
        function isArrayLike( obj ) {

            if ( !obj ) {

                return false;

            }

    
            var length = obj.length,

                type = $.type( obj );

    
            if ( obj.nodeType === 1 && length ) {

                return true;

            }

    
            return type === 'array' || type !== 'function' && type !== 'string' &&

                    (length === 0 || typeof length === 'number' && length > 0 &&

                    (length - 1) in obj);

        }

    
        function Widget( uploader ) {

            this.owner = uploader;

            this.options = uploader.options;

        }

    
        $.extend( Widget.prototype, {

    
            init: Base.noop,

    
            // 类Backbone的事件监听声明，监听uploader实例上的事件

            // widget直接无法监听事件，事件只能通过uploader来传递

            invoke: function( apiName, args ) {

    
                /*

                    {

                        'make-thumb': 'makeThumb'

                    }

                 */

                var map = this.responseMap;

    
                // 如果无API响应声明则忽略

                if ( !map || !(apiName in map) || !(map[ apiName ] in this) ||

                        !$.isFunction( this[ map[ apiName ] ] ) ) {

    
                    return IGNORE;

                }

    
                return this[ map[ apiName ] ].apply( this, args );

    
            },

    
            /**

             * 发送命令。当传入`callback`或者`handler`中返回`promise`时。返回一个当所有`handler`中的promise都完成后完成的新`promise`。

             * @method request

             * @grammar request( command, args ) => * | Promise

             * @grammar request( command, args, callback ) => Promise

             * @for  Uploader

             */

            request: function() {

                return this.owner.request.apply( this.owner, arguments );

            }

        });

    
        // 扩展Uploader.

        $.extend( Uploader.prototype, {

    
            // 覆写_init用来初始化widgets

            _init: function() {

                var me = this,

                    widgets = me._widgets = [];

    
                $.each( widgetClass, function( _, klass ) {

                    widgets.push( new klass( me ) );

                });

    
                return _init.apply( me, arguments );

            },

    
            request: function( apiName, args, callback ) {

                var i = 0,

                    widgets = this._widgets,

                    len = widgets.length,

                    rlts = [],

                    dfds = [],

                    widget, rlt, promise, key;

    
                args = isArrayLike( args ) ? args : [ args ];

    
                for ( ; i < len; i++ ) {

                    widget = widgets[ i ];

                    rlt = widget.invoke( apiName, args );

    
                    if ( rlt !== IGNORE ) {

    
                        // Deferred对象

                        if ( Base.isPromise( rlt ) ) {

                            dfds.push( rlt );

                        } else {

                            rlts.push( rlt );

                        }

                    }

                }

    
                // 如果有callback，则用异步方式。

                if ( callback || dfds.length ) {

                    promise = Base.when.apply( Base, dfds );

                    key = promise.pipe ? 'pipe' : 'then';

    
                    // 很重要不能删除。删除了会死循环。

                    // 保证执行顺序。让callback总是在下一个tick中执行。

                    return promise[ key ](function() {

                                var deferred = Base.Deferred(),

                                    args = arguments;

    
                                setTimeout(function() {

                                    deferred.resolve.apply( deferred, args );

                                }, 1 );

    
                                return deferred.promise();

                            })[ key ]( callback || Base.noop );

                } else {

                    return rlts[ 0 ];

                }

            }

        });

    
        /**

         * 添加组件

         * @param  {object} widgetProto 组件原型，构造函数通过constructor属性定义

         * @param  {object} responseMap API名称与函数实现的映射

         * @example

         *     Uploader.register( {

         *         init: function( options ) {},

         *         makeThumb: function() {}

         *     }, {

         *         'make-thumb': 'makeThumb'

         *     } );

         */

        Uploader.register = Widget.register = function( responseMap, widgetProto ) {

            var map = { init: 'init' },

                klass;

    
            if ( arguments.length === 1 ) {

                widgetProto = responseMap;

                widgetProto.responseMap = map;

            } else {

                widgetProto.responseMap = $.extend( map, responseMap );

            }

    
            klass = Base.inherits( Widget, widgetProto );

            widgetClass.push( klass );

    
            return klass;

        };

    
        return Widget;

    });

    /**

     * @fileOverview DragAndDrop Widget。

     */

    define('widgets/filednd',[

        'base',

        'uploader',

        'lib/dnd',

        'widgets/widget'

    ], function( Base, Uploader, Dnd ) {

        var $ = Base.$;

    
        Uploader.options.dnd = '';

    
        /**

         * @property {Selector} [dnd=undefined]  指定Drag And Drop拖拽的容器，如果不指定，则不启动。

         * @namespace options

         * @for Uploader

         */

    
        /**

         * @event dndAccept

         * @param {DataTransferItemList} items DataTransferItem

         * @description 阻止此事件可以拒绝某些类型的文件拖入进来。目前只有 chrome 提供这样的 API，且只能通过 mime-type 验证。

         * @for  Uploader

         */

        return Uploader.register({

            init: function( opts ) {

    
                if ( !opts.dnd ||

                        this.request('predict-runtime-type') !== 'html5' ) {

                    return;

                }

    
                var me = this,

                    deferred = Base.Deferred(),

                    options = $.extend({}, {

                        disableGlobalDnd: opts.disableGlobalDnd,

                        container: opts.dnd,

                        accept: opts.accept

                    }),

                    dnd;

    
                dnd = new Dnd( options );

    
                dnd.once( 'ready', deferred.resolve );

                dnd.on( 'drop', function( files ) {

                    me.request( 'add-file', [ files ]);

                });

    
                // 检测文件是否全部允许添加。

                dnd.on( 'accept', function( items ) {

                    return me.owner.trigger( 'dndAccept', items );

                });

    
                dnd.init();

    
                return deferred.promise();

            }

        });

    });

    
    /**

     * @fileOverview 错误信息

     */

    define('lib/filepaste',[

        'base',

        'mediator',

        'runtime/client'

    ], function( Base, Mediator, RuntimeClent ) {

    
        var $ = Base.$;

    
        function FilePaste( opts ) {

            opts = this.options = $.extend({}, opts );

            opts.container = $( opts.container || document.body );

            RuntimeClent.call( this, 'FilePaste' );

        }

    
        Base.inherits( RuntimeClent, {

            constructor: FilePaste,

    
            init: function() {

                var me = this;

    
                me.connectRuntime( me.options, function() {

                    me.exec('init');

                    me.trigger('ready');

                });

            },

    
            destroy: function() {

                this.exec('destroy');

                this.disconnectRuntime();

                this.off();

            }

        });

    
        Mediator.installTo( FilePaste.prototype );

    
        return FilePaste;

    });

    /**

     * @fileOverview 组件基类。

     */

    define('widgets/filepaste',[

        'base',

        'uploader',

        'lib/filepaste',

        'widgets/widget'

    ], function( Base, Uploader, FilePaste ) {

        var $ = Base.$;

    
        /**

         * @property {Selector} [paste=undefined]  指定监听paste事件的容器，如果不指定，不启用此功能。此功能为通过粘贴来添加截屏的图片。建议设置为`document.body`.

         * @namespace options

         * @for Uploader

         */

        return Uploader.register({

            init: function( opts ) {

    
                if ( !opts.paste ||

                        this.request('predict-runtime-type') !== 'html5' ) {

                    return;

                }

    
                var me = this,

                    deferred = Base.Deferred(),

                    options = $.extend({}, {

                        container: opts.paste,

                        accept: opts.accept

                    }),

                    paste;

    
                paste = new FilePaste( options );

    
                paste.once( 'ready', deferred.resolve );

                paste.on( 'paste', function( files ) {

                    me.owner.request( 'add-file', [ files ]);

                });

                paste.init();

    
                return deferred.promise();

            }

        });

    });

    /**

     * @fileOverview Blob

     */

    define('lib/blob',[

        'base',

        'runtime/client'

    ], function( Base, RuntimeClient ) {

    
        function Blob( ruid, source ) {

            var me = this;

    
            me.source = source;

            me.ruid = ruid;

    
            RuntimeClient.call( me, 'Blob' );

    
            this.uid = source.uid || this.uid;

            this.type = source.type || '';

            this.size = source.size || 0;

    
            if ( ruid ) {

                me.connectRuntime( ruid );

            }

        }

    
        Base.inherits( RuntimeClient, {

            constructor: Blob,

    
            slice: function( start, end ) {

                return this.exec( 'slice', start, end );

            },

    
            getSource: function() {

                return this.source;

            }

        });

    
        return Blob;

    });

    /**

     * 为了统一化Flash的File和HTML5的File而存在。

     * 以至于要调用Flash里面的File，也可以像调用HTML5版本的File一下。

     * @fileOverview File

     */

    define('lib/file',[

        'base',

        'lib/blob'

    ], function( Base, Blob ) {

    
        var uid = 1,

            rExt = /\.([^.]+)$/;

    
        function File( ruid, file ) {

            var ext;

    
            Blob.apply( this, arguments );

            this.name = file.name || ('untitled' + uid++);

            ext = rExt.exec( file.name ) ? RegExp.$1.toLowerCase() : '';

    
            // todo 支持其他类型文件的转换。

    
            // 如果有mimetype, 但是文件名里面没有找出后缀规律

            if ( !ext && this.type ) {

                ext = /\/(jpg|jpeg|png|gif|bmp)$/i.exec( this.type ) ?

                        RegExp.$1.toLowerCase() : '';

                this.name += '.' + ext;

            }

    
            // 如果没有指定mimetype, 但是知道文件后缀。

            if ( !this.type &&  ~'jpg,jpeg,png,gif,bmp'.indexOf( ext ) ) {

                this.type = 'image/' + (ext === 'jpg' ? 'jpeg' : ext);

            }

    
            this.ext = ext;

            this.lastModifiedDate = file.lastModifiedDate ||

                    (new Date()).toLocaleString();

        }

    
        return Base.inherits( Blob, File );

    });

    
    /**

     * @fileOverview 错误信息

     */

    define('lib/filepicker',[

        'base',

        'runtime/client',

        'lib/file'

    ], function( Base, RuntimeClent, File ) {

    
        var $ = Base.$;

    
        function FilePicker( opts ) {

            opts = this.options = $.extend({}, FilePicker.options, opts );

    
            opts.container = $( opts.id );

    
            if ( !opts.container.length ) {

                throw new Error('按钮指定错误');

            }

    
            opts.innerHTML = opts.innerHTML || opts.label ||

                    opts.container.html() || '';

    
            opts.button = $( opts.button || document.createElement('div') );

            opts.button.html( opts.innerHTML );

            opts.container.html( opts.button );

    
            RuntimeClent.call( this, 'FilePicker', true );

        }

    
        FilePicker.options = {

            button: null,

            container: null,

            label: null,

            innerHTML: null,

            multiple: true,

            accept: null,

            name: 'file'

        };

    
        Base.inherits( RuntimeClent, {

            constructor: FilePicker,

    
            init: function() {

                var me = this,

                    opts = me.options,

                    button = opts.button;

    
                button.addClass('webuploader-pick');

    
                me.on( 'all', function( type ) {

                    var files;

    
                    switch ( type ) {

                        case 'mouseenter':

                            button.addClass('webuploader-pick-hover');

                            break;

    
                        case 'mouseleave':

                            button.removeClass('webuploader-pick-hover');

                            break;

    
                        case 'change':

                            files = me.exec('getFiles');

                            me.trigger( 'select', $.map( files, function( file ) {

                                file = new File( me.getRuid(), file );

    
                                // 记录来源。

                                file._refer = opts.container;

                                return file;

                            }), opts.container );

                            break;

                    }

                });

    
                me.connectRuntime( opts, function() {

                    me.refresh();

                    me.exec( 'init', opts );

                    me.trigger('ready');

                });

    
                $( window ).on( 'resize', function() {

                    me.refresh();

                });

            },

    
            refresh: function() {

                var shimContainer = this.getRuntime().getContainer(),

                    button = this.options.button,

                    width = button.outerWidth ?

                            button.outerWidth() : button.width(),

    
                    height = button.outerHeight ?

                            button.outerHeight() : button.height(),

    
                    pos = button.offset();

    
                width && height && shimContainer.css({

                    bottom: 'auto',

                    right: 'auto',

                    width: width + 'px',

                    height: height + 'px'

                }).offset( pos );

            },

    
            enable: function() {

                var btn = this.options.button;

    
                btn.removeClass('webuploader-pick-disable');

                this.refresh();

            },

    
            disable: function() {

                var btn = this.options.button;

    
                this.getRuntime().getContainer().css({

                    top: '-99999px'

                });

    
                btn.addClass('webuploader-pick-disable');

            },

    
            destroy: function() {

                if ( this.runtime ) {

                    this.exec('destroy');

                    this.disconnectRuntime();

                }

            }

        });

    
        return FilePicker;

    });

    
    /**

     * @fileOverview 文件选择相关

     */

    define('widgets/filepicker',[

        'base',

        'uploader',

        'lib/filepicker',

        'widgets/widget'

    ], function( Base, Uploader, FilePicker ) {

        var $ = Base.$;

    
        $.extend( Uploader.options, {

    
            /**

             * @property {Selector | Object} [pick=undefined]

             * @namespace options

             * @for Uploader

             * @description 指定选择文件的按钮容器，不指定则不创建按钮。

             *

             * * `id` {Seletor} 指定选择文件的按钮容器，不指定则不创建按钮。

             * * `label` {String} 请采用 `innerHTML` 代替

             * * `innerHTML` {String} 指定按钮文字。不指定时优先从指定的容器中看是否自带文字。

             * * `multiple` {Boolean} 是否开起同时选择多个文件能力。

             */

            pick: null,

    
            /**

             * @property {Arroy} [accept=null]

             * @namespace options

             * @for Uploader

             * @description 指定接受哪些类型的文件。 由于目前还有ext转mimeType表，所以这里需要分开指定。

             *

             * * `title` {String} 文字描述

             * * `extensions` {String} 允许的文件后缀，不带点，多个用逗号分割。

             * * `mimeTypes` {String} 多个用逗号分割。

             *

             * 如：

             *

             * ```

             * {

             *     title: 'Images',

             *     extensions: 'gif,jpg,jpeg,bmp,png',

             *     mimeTypes: 'image/*'

             * }

             * ```

             */

            accept: null/*{

                title: 'Images',

                extensions: 'gif,jpg,jpeg,bmp,png',

                mimeTypes: 'image/*'

            }*/

        });

    
        return Uploader.register({

            'add-btn': 'addButton',

            refresh: 'refresh',

            disable: 'disable',

            enable: 'enable'

        }, {

    
            init: function( opts ) {

                this.pickers = [];

                return opts.pick && this.addButton( opts.pick );

            },

    
            refresh: function() {

                $.each( this.pickers, function() {

                    this.refresh();

                });

            },

    
            /**

             * @method addButton

             * @for Uploader

             * @grammar addButton( pick ) => Promise

             * @description

             * 添加文件选择按钮，如果一个按钮不够，需要调用此方法来添加。参数跟[options.pick](#WebUploader:Uploader:options)一致。

             * @example

             * uploader.addButton({

             *     id: '#btnContainer',

             *     innerHTML: '选择文件'

             * });

             */

            addButton: function( pick ) {

                var me = this,

                    opts = me.options,

                    accept = opts.accept,

                    options, picker, deferred;

    
                if ( !pick ) {

                    return;

                }

    
                deferred = Base.Deferred();

                $.isPlainObject( pick ) || (pick = {

                    id: pick

                });

    
                options = $.extend({}, pick, {

                    accept: $.isPlainObject( accept ) ? [ accept ] : accept,

                    swf: opts.swf,

                    runtimeOrder: opts.runtimeOrder

                });

    
                picker = new FilePicker( options );

    
                picker.once( 'ready', deferred.resolve );

                picker.on( 'select', function( files ) {

                    me.owner.request( 'add-file', [ files ]);

                });

                picker.init();

    
                this.pickers.push( picker );

    
                return deferred.promise();

            },

    
            disable: function() {

                $.each( this.pickers, function() {

                    this.disable();

                });

            },

    
            enable: function() {

                $.each( this.pickers, function() {

                    this.enable();

                });

            }

        });

    });

    /**

     * @fileOverview 文件属性封装

     */

    define('file',[

        'base',

        'mediator'

    ], function( Base, Mediator ) {

    
        var $ = Base.$,

            idPrefix = 'WU_FILE_',

            idSuffix = 0,

            rExt = /\.([^.]+)$/,

            statusMap = {};

    
        function gid() {

            return idPrefix + idSuffix++;

        }

    
        /**

         * 文件类

         * @class File

         * @constructor 构造函数

         * @grammar new File( source ) => File

         * @param {Lib.File} source [lib.File](#Lib.File)实例, 此source对象是带有Runtime信息的。

         */

        function WUFile( source ) {

    
            /**

             * 文件名，包括扩展名（后缀）

             * @property name

             * @type {string}

             */

            this.name = source.name || 'Untitled';

    
            /**

             * 文件体积（字节）

             * @property size

             * @type {uint}

             * @default 0

             */

            this.size = source.size || 0;

    
            /**

             * 文件MIMETYPE类型，与文件类型的对应关系请参考[http://t.cn/z8ZnFny](http://t.cn/z8ZnFny)

             * @property type

             * @type {string}

             * @default 'application'

             */

            this.type = source.type || 'application';

    
            /**

             * 文件最后修改日期

             * @property lastModifiedDate

             * @type {int}

             * @default 当前时间戳

             */

            this.lastModifiedDate = source.lastModifiedDate || (new Date() * 1);

    
            /**

             * 文件ID，每个对象具有唯一ID，与文件名无关

             * @property id

             * @type {string}

             */

            this.id = gid();

    
            /**

             * 文件扩展名，通过文件名获取，例如test.png的扩展名为png

             * @property ext

             * @type {string}

             */

            this.ext = rExt.exec( this.name ) ? RegExp.$1 : '';

    
    
            /**

             * 状态文字说明。在不同的status语境下有不同的用途。

             * @property statusText

             * @type {string}

             */

            this.statusText = '';

    
            // 存储文件状态，防止通过属性直接修改

            statusMap[ this.id ] = WUFile.Status.INITED;

    
            this.source = source;

            this.loaded = 0;

    
            this.on( 'error', function( msg ) {

                this.setStatus( WUFile.Status.ERROR, msg );

            });

        }

    
        $.extend( WUFile.prototype, {

    
            /**

             * 设置状态，状态变化时会触发`change`事件。

             * @method setStatus

             * @grammar setStatus( status[, statusText] );

             * @param {File.Status|String} status [文件状态值](#WebUploader:File:File.Status)

             * @param {String} [statusText=''] 状态说明，常在error时使用，用http, abort,server等来标记是由于什么原因导致文件错误。

             */

            setStatus: function( status, text ) {

    
                var prevStatus = statusMap[ this.id ];

    
                typeof text !== 'undefined' && (this.statusText = text);

    
                if ( status !== prevStatus ) {

                    statusMap[ this.id ] = status;

                    /**

                     * 文件状态变化

                     * @event statuschange

                     */

                    this.trigger( 'statuschange', status, prevStatus );

                }

    
            },

    
            /**

             * 获取文件状态

             * @return {File.Status}

             * @example

                     文件状态具体包括以下几种类型：

                     {

                         // 初始化

                        INITED:     0,

                        // 已入队列

                        QUEUED:     1,

                        // 正在上传

                        PROGRESS:     2,

                        // 上传出错

                        ERROR:         3,

                        // 上传成功

                        COMPLETE:     4,

                        // 上传取消

                        CANCELLED:     5

                    }

             */

            getStatus: function() {

                return statusMap[ this.id ];

            },

    
            /**

             * 获取文件原始信息。

             * @return {*}

             */

            getSource: function() {

                return this.source;

            },

    
            destory: function() {

                delete statusMap[ this.id ];

            }

        });

    
        Mediator.installTo( WUFile.prototype );

    
        /**

         * 文件状态值，具体包括以下几种类型：

         * * `inited` 初始状态

         * * `queued` 已经进入队列, 等待上传

         * * `progress` 上传中

         * * `complete` 上传完成。

         * * `error` 上传出错，可重试

         * * `interrupt` 上传中断，可续传。

         * * `invalid` 文件不合格，不能重试上传。会自动从队列中移除。

         * * `cancelled` 文件被移除。

         * @property {Object} Status

         * @namespace File

         * @class File

         * @static

         */

        WUFile.Status = {

            INITED:     'inited',    // 初始状态

            QUEUED:     'queued',    // 已经进入队列, 等待上传

            PROGRESS:   'progress',    // 上传中

            ERROR:      'error',    // 上传出错，可重试

            COMPLETE:   'complete',    // 上传完成。

            CANCELLED:  'cancelled',    // 上传取消。

            INTERRUPT:  'interrupt',    // 上传中断，可续传。

            INVALID:    'invalid'    // 文件不合格，不能重试上传。

        };

    
        return WUFile;

    });

    
    /**

     * @fileOverview 文件队列

     */

    define('queue',[

        'base',

        'mediator',

        'file'

    ], function( Base, Mediator, WUFile ) {

    
        var $ = Base.$,

            STATUS = WUFile.Status;

    
        /**

         * 文件队列, 用来存储各个状态中的文件。

         * @class Queue

         * @extends Mediator

         */

        function Queue() {

    
            /**

             * 统计文件数。

             * * `numOfQueue` 队列中的文件数。

             * * `numOfSuccess` 上传成功的文件数

             * * `numOfCancel` 被移除的文件数

             * * `numOfProgress` 正在上传中的文件数

             * * `numOfUploadFailed` 上传错误的文件数。

             * * `numOfInvalid` 无效的文件数。

             * @property {Object} stats

             */

            this.stats = {

                numOfQueue: 0,

                numOfSuccess: 0,

                numOfCancel: 0,

                numOfProgress: 0,

                numOfUploadFailed: 0,

                numOfInvalid: 0

            };

    
            // 上传队列，仅包括等待上传的文件

            this._queue = [];

    
            // 存储所有文件

            this._map = {};

        }

    
        $.extend( Queue.prototype, {

    
            /**

             * 将新文件加入对队列尾部

             *

             * @method append

             * @param  {File} file   文件对象

             */

            append: function( file ) {

                this._queue.push( file );

                this._fileAdded( file );

                return this;

            },

    
            /**

             * 将新文件加入对队列头部

             *

             * @method prepend

             * @param  {File} file   文件对象

             */

            prepend: function( file ) {

                this._queue.unshift( file );

                this._fileAdded( file );

                return this;

            },

    
            /**

             * 获取文件对象

             *

             * @method getFile

             * @param  {String} fileId   文件ID

             * @return {File}

             */

            getFile: function( fileId ) {

                if ( typeof fileId !== 'string' ) {

                    return fileId;

                }

                return this._map[ fileId ];

            },

    
            /**

             * 从队列中取出一个指定状态的文件。

             * @grammar fetch( status ) => File

             * @method fetch

             * @param {String} status [文件状态值](#WebUploader:File:File.Status)

             * @return {File} [File](#WebUploader:File)

             */

            fetch: function( status ) {

                var len = this._queue.length,

                    i, file;

    
                status = status || STATUS.QUEUED;

    
                for ( i = 0; i < len; i++ ) {

                    file = this._queue[ i ];

    
                    if ( status === file.getStatus() ) {

                        return file;

                    }

                }

    
                return null;

            },

    
            /**

             * 对队列进行排序，能够控制文件上传顺序。

             * @grammar sort( fn ) => undefined

             * @method sort

             * @param {Function} fn 排序方法

             */

            sort: function( fn ) {

                if ( typeof fn === 'function' ) {

                    this._queue.sort( fn );

                }

            },

    
            /**

             * 获取指定类型的文件列表, 列表中每一个成员为[File](#WebUploader:File)对象。

             * @grammar getFiles( [status1[, status2 ...]] ) => Array

             * @method getFiles

             * @param {String} [status] [文件状态值](#WebUploader:File:File.Status)

             */

            getFiles: function() {

                var sts = [].slice.call( arguments, 0 ),

                    ret = [],

                    i = 0,

                    len = this._queue.length,

                    file;

    
                for ( ; i < len; i++ ) {

                    file = this._queue[ i ];

    
                    if ( sts.length && !~$.inArray( file.getStatus(), sts ) ) {

                        continue;

                    }

    
                    ret.push( file );

                }

    
                return ret;

            },

    
            _fileAdded: function( file ) {

                var me = this,

                    existing = this._map[ file.id ];

    
                if ( !existing ) {

                    this._map[ file.id ] = file;

    
                    file.on( 'statuschange', function( cur, pre ) {

                        me._onFileStatusChange( cur, pre );

                    });

                }

    
                file.setStatus( STATUS.QUEUED );

            },

    
            _onFileStatusChange: function( curStatus, preStatus ) {

                var stats = this.stats;

    
                switch ( preStatus ) {

                    case STATUS.PROGRESS:

                        stats.numOfProgress--;

                        break;

    
                    case STATUS.QUEUED:

                        stats.numOfQueue --;

                        break;

    
                    case STATUS.ERROR:

                        stats.numOfUploadFailed--;

                        break;

    
                    case STATUS.INVALID:

                        stats.numOfInvalid--;

                        break;

                }

    
                switch ( curStatus ) {

                    case STATUS.QUEUED:

                        stats.numOfQueue++;

                        break;

    
                    case STATUS.PROGRESS:

                        stats.numOfProgress++;

                        break;

    
                    case STATUS.ERROR:

                        stats.numOfUploadFailed++;

                        break;

    
                    case STATUS.COMPLETE:

                        stats.numOfSuccess++;

                        break;

    
                    case STATUS.CANCELLED:

                        stats.numOfCancel++;

                        break;

    
                    case STATUS.INVALID:

                        stats.numOfInvalid++;

                        break;

                }

            }

    
        });

    
        Mediator.installTo( Queue.prototype );

    
        return Queue;

    });

    /**

     * @fileOverview 队列

     */

    define('widgets/queue',[

        'base',

        'uploader',

        'queue',

        'file',

        'lib/file',

        'runtime/client',

        'widgets/widget'

    ], function( Base, Uploader, Queue, WUFile, File, RuntimeClient ) {

    
        var $ = Base.$,

            rExt = /\.\w+$/,

            Status = WUFile.Status;

    
        return Uploader.register({

            'sort-files': 'sortFiles',

            'add-file': 'addFiles',

            'get-file': 'getFile',

            'fetch-file': 'fetchFile',

            'get-stats': 'getStats',

            'get-files': 'getFiles',

            'remove-file': 'removeFile',

            'retry': 'retry',

            'reset': 'reset',

            'accept-file': 'acceptFile'

        }, {

    
            init: function( opts ) {

                var me = this,

                    deferred, len, i, item, arr, accept, runtime;

    
                if ( $.isPlainObject( opts.accept ) ) {

                    opts.accept = [ opts.accept ];

                }

    
                // accept中的中生成匹配正则。

                if ( opts.accept ) {

                    arr = [];

    
                    for ( i = 0, len = opts.accept.length; i < len; i++ ) {

                        item = opts.accept[ i ].extensions;

                        item && arr.push( item );

                    }

    
                    if ( arr.length ) {

                        accept = '\\.' + arr.join(',')

                                .replace( /,/g, '$|\\.' )

                                .replace( /\*/g, '.*' ) + '$';

                    }

    
                    me.accept = new RegExp( accept, 'i' );

                }

    
                me.queue = new Queue();

                me.stats = me.queue.stats;

    
                // 如果当前不是html5运行时，那就算了。

                // 不执行后续操作

                if ( this.request('predict-runtime-type') !== 'html5' ) {

                    return;

                }

    
                // 创建一个 html5 运行时的 placeholder

                // 以至于外部添加原生 File 对象的时候能正确包裹一下供 webuploader 使用。

                deferred = Base.Deferred();

                runtime = new RuntimeClient('Placeholder');

                runtime.connectRuntime({

                    runtimeOrder: 'html5'

                }, function() {

                    me._ruid = runtime.getRuid();

                    deferred.resolve();

                });

                return deferred.promise();

            },

    
    
            // 为了支持外部直接添加一个原生File对象。

            _wrapFile: function( file ) {

                if ( !(file instanceof WUFile) ) {

    
                    if ( !(file instanceof File) ) {

                        if ( !this._ruid ) {

                            throw new Error('Can\'t add external files.');

                        }

                        file = new File( this._ruid, file );

                    }

    
                    file = new WUFile( file );

                }

    
                return file;

            },

    
            // 判断文件是否可以被加入队列

            acceptFile: function( file ) {

                var invalid = !file || file.size < 6 || this.accept &&

    
                        // 如果名字中有后缀，才做后缀白名单处理。

                        rExt.exec( file.name ) && !this.accept.test( file.name );

    
                return !invalid;

            },

    
    
            /**

             * @event beforeFileQueued

             * @param {File} file File对象

             * @description 当文件被加入队列之前触发，此事件的handler返回值为`false`，则此文件不会被添加进入队列。

             * @for  Uploader

             */

    
            /**

             * @event fileQueued

             * @param {File} file File对象

             * @description 当文件被加入队列以后触发。

             * @for  Uploader

             */

    
            _addFile: function( file ) {

                var me = this;

    
                file = me._wrapFile( file );

    
                // 不过类型判断允许不允许，先派送 `beforeFileQueued`

                if ( !me.owner.trigger( 'beforeFileQueued', file ) ) {

                    return;

                }

    
                // 类型不匹配，则派送错误事件，并返回。

                if ( !me.acceptFile( file ) ) {

                    me.owner.trigger( 'error', 'Q_TYPE_DENIED', file );

                    return;

                }

    
                me.queue.append( file );

                me.owner.trigger( 'fileQueued', file );

                return file;

            },

    
            getFile: function( fileId ) {

                return this.queue.getFile( fileId );

            },

    
            /**

             * @event filesQueued

             * @param {File} files 数组，内容为原始File(lib/File）对象。

             * @description 当一批文件添加进队列以后触发。

             * @for  Uploader

             */

    
            /**

             * @method addFiles

             * @grammar addFiles( file ) => undefined

             * @grammar addFiles( [file1, file2 ...] ) => undefined

             * @param {Array of File or File} [files] Files 对象 数组

             * @description 添加文件到队列

             * @for  Uploader

             */

            addFiles: function( files ) {

                var me = this;

    
                if ( !files.length ) {

                    files = [ files ];

                }

    
                files = $.map( files, function( file ) {

                    return me._addFile( file );

                });

    
                me.owner.trigger( 'filesQueued', files );

    
                if ( me.options.auto ) {

                    me.request('start-upload');

                }

            },

    
            getStats: function() {

                return this.stats;

            },

    
            /**

             * @event fileDequeued

             * @param {File} file File对象

             * @description 当文件被移除队列后触发。

             * @for  Uploader

             */

    
            /**

             * @method removeFile

             * @grammar removeFile( file ) => undefined

             * @grammar removeFile( id ) => undefined

             * @param {File|id} file File对象或这File对象的id

             * @description 移除某一文件。

             * @for  Uploader

             * @example

             *

             * $li.on('click', '.remove-this', function() {

             *     uploader.removeFile( file );

             * })

             */

            removeFile: function( file ) {

                var me = this;

    
                file = file.id ? file : me.queue.getFile( file );

    
                file.setStatus( Status.CANCELLED );

                me.owner.trigger( 'fileDequeued', file );

            },

    
            /**

             * @method getFiles

             * @grammar getFiles() => Array

             * @grammar getFiles( status1, status2, status... ) => Array

             * @description 返回指定状态的文件集合，不传参数将返回所有状态的文件。

             * @for  Uploader

             * @example

             * console.log( uploader.getFiles() );    // => all files

             * console.log( uploader.getFiles('error') )    // => all error files.

             */

            getFiles: function() {

                return this.queue.getFiles.apply( this.queue, arguments );

            },

    
            fetchFile: function() {

                return this.queue.fetch.apply( this.queue, arguments );

            },

    
            /**

             * @method retry

             * @grammar retry() => undefined

             * @grammar retry( file ) => undefined

             * @description 重试上传，重试指定文件，或者从出错的文件开始重新上传。

             * @for  Uploader

             * @example

             * function retry() {

             *     uploader.retry();

             * }

             */

            retry: function( file, noForceStart ) {

                var me = this,

                    files, i, len;

    
                if ( file ) {

                    file = file.id ? file : me.queue.getFile( file );

                    file.setStatus( Status.QUEUED );

                    noForceStart || me.request('start-upload');

                    return;

                }

    
                files = me.queue.getFiles( Status.ERROR );

                i = 0;

                len = files.length;

    
                for ( ; i < len; i++ ) {

                    file = files[ i ];

                    file.setStatus( Status.QUEUED );

                }

    
                me.request('start-upload');

            },

    
            /**

             * @method sort

             * @grammar sort( fn ) => undefined

             * @description 排序队列中的文件，在上传之前调整可以控制上传顺序。

             * @for  Uploader

             */

            sortFiles: function() {

                return this.queue.sort.apply( this.queue, arguments );

            },

    
            /**

             * @method reset

             * @grammar reset() => undefined

             * @description 重置uploader。目前只重置了队列。

             * @for  Uploader

             * @example

             * uploader.reset();

             */

            reset: function() {

                this.queue = new Queue();

                this.stats = this.queue.stats;

            }

        });

    
    });

    /**

     * @fileOverview 添加获取Runtime相关信息的方法。

     */

    define('widgets/runtime',[

        'uploader',

        'runtime/runtime',

        'widgets/widget'

    ], function( Uploader, Runtime ) {

    
        Uploader.support = function() {

            return Runtime.hasRuntime.apply( Runtime, arguments );

        };

    
        return Uploader.register({

            'predict-runtime-type': 'predictRuntmeType'

        }, {

    
            init: function() {

                if ( !this.predictRuntmeType() ) {

                    throw Error('Runtime Error');

                }

            },

    
            /**

             * 预测Uploader将采用哪个`Runtime`

             * @grammar predictRuntmeType() => String

             * @method predictRuntmeType

             * @for  Uploader

             */

            predictRuntmeType: function() {

                var orders = this.options.runtimeOrder || Runtime.orders,

                    type = this.type,

                    i, len;

    
                if ( !type ) {

                    orders = orders.split( /\s*,\s*/g );

    
                    for ( i = 0, len = orders.length; i < len; i++ ) {

                        if ( Runtime.hasRuntime( orders[ i ] ) ) {

                            this.type = type = orders[ i ];

                            break;

                        }

                    }

                }

    
                return type;

            }

        });

    });

    /**

     * @fileOverview Transport

     */

    define('lib/transport',[

        'base',

        'runtime/client',

        'mediator'

    ], function( Base, RuntimeClient, Mediator ) {

    
        var $ = Base.$;

    
        function Transport( opts ) {

            var me = this;

    
            opts = me.options = $.extend( true, {}, Transport.options, opts || {} );

            RuntimeClient.call( this, 'Transport' );

    
            this._blob = null;

            this._formData = opts.formData || {};

            this._headers = opts.headers || {};

    
            this.on( 'progress', this._timeout );

            this.on( 'load error', function() {

                me.trigger( 'progress', 1 );

                clearTimeout( me._timer );

            });

        }

    
        Transport.options = {

            server: '',

            method: 'POST',

    
            // 跨域时，是否允许携带cookie, 只有html5 runtime才有效

            withCredentials: false,

            fileVal: 'file',

            timeout: 2 * 60 * 1000,    // 2分钟

            formData: {},

            headers: {},

            sendAsBinary: false

        };

    
        $.extend( Transport.prototype, {

    
            // 添加Blob, 只能添加一次，最后一次有效。

            appendBlob: function( key, blob, filename ) {

                var me = this,

                    opts = me.options;

    
                if ( me.getRuid() ) {

                    me.disconnectRuntime();

                }

    
                // 连接到blob归属的同一个runtime.

                me.connectRuntime( blob.ruid, function() {

                    me.exec('init');

                });

    
                me._blob = blob;

                opts.fileVal = key || opts.fileVal;

                opts.filename = filename || opts.filename;

            },

    
            // 添加其他字段

            append: function( key, value ) {

                if ( typeof key === 'object' ) {

                    $.extend( this._formData, key );

                } else {

                    this._formData[ key ] = value;

                }

            },

    
            setRequestHeader: function( key, value ) {

                if ( typeof key === 'object' ) {

                    $.extend( this._headers, key );

                } else {

                    this._headers[ key ] = value;

                }

            },

    
            send: function( method ) {

                this.exec( 'send', method );

                this._timeout();

            },

    
            abort: function() {

                clearTimeout( this._timer );

                return this.exec('abort');

            },

    
            destroy: function() {

                this.trigger('destroy');

                this.off();

                this.exec('destroy');

                this.disconnectRuntime();

            },

    
            getResponse: function() {

                return this.exec('getResponse');

            },

    
            getResponseAsJson: function() {

                return this.exec('getResponseAsJson');

            },

    
            getStatus: function() {

                return this.exec('getStatus');

            },

    
            _timeout: function() {

                var me = this,

                    duration = me.options.timeout;

    
                if ( !duration ) {

                    return;

                }

    
                clearTimeout( me._timer );

                me._timer = setTimeout(function() {

                    me.abort();

                    me.trigger( 'error', 'timeout' );

                }, duration );

            }

    
        });

    
        // 让Transport具备事件功能。

        Mediator.installTo( Transport.prototype );

    
        return Transport;

    });

    /**

     * @fileOverview 负责文件上传相关。

     */

    define('widgets/upload',[

        'base',

        'uploader',

        'file',

        'lib/transport',

        'widgets/widget'

    ], function( Base, Uploader, WUFile, Transport ) {

    
        var $ = Base.$,

            isPromise = Base.isPromise,

            Status = WUFile.Status;

    
        // 添加默认配置项

        $.extend( Uploader.options, {

    
    
            /**

             * @property {Boolean} [prepareNextFile=false]

             * @namespace options

             * @for Uploader

             * @description 是否允许在文件传输时提前把下一个文件准备好。

             * 对于一个文件的准备工作比较耗时，比如图片压缩，md5序列化。

             * 如果能提前在当前文件传输期处理，可以节省总体耗时。

             */

            prepareNextFile: false,

    
            /**

             * @property {Boolean} [chunked=false]

             * @namespace options

             * @for Uploader

             * @description 是否要分片处理大文件上传。

             */

            chunked: false,

    
            /**

             * @property {Boolean} [chunkSize=5242880]

             * @namespace options

             * @for Uploader

             * @description 如果要分片，分多大一片？ 默认大小为5M.

             */

            chunkSize: 5 * 1024 * 1024,

    
            /**

             * @property {Boolean} [chunkRetry=2]

             * @namespace options

             * @for Uploader

             * @description 如果某个分片由于网络问题出错，允许自动重传多少次？

             */

            chunkRetry: 2,

    
            /**

             * @property {Boolean} [threads=3]

             * @namespace options

             * @for Uploader

             * @description 上传并发数。允许同时最大上传进程数。

             */

            threads: 3,

    
    
            /**

             * @property {Object} [formData]

             * @namespace options

             * @for Uploader

             * @description 文件上传请求的参数表，每次发送都会发送此对象中的参数。

             */

            formData: null

    
            /**

             * @property {Object} [fileVal='file']

             * @namespace options

             * @for Uploader

             * @description 设置文件上传域的name。

             */

    
            /**

             * @property {Object} [method='POST']

             * @namespace options

             * @for Uploader

             * @description 文件上传方式，`POST`或者`GET`。

             */

    
            /**

             * @property {Object} [sendAsBinary=false]

             * @namespace options

             * @for Uploader

             * @description 是否已二进制的流的方式发送文件，这样整个上传内容`php://input`都为文件内容，

             * 其他参数在$_GET数组中。

             */

        });

    
        // 负责将文件切片。

        function CuteFile( file, chunkSize ) {

            var pending = [],

                blob = file.source,

                total = blob.size,

                chunks = chunkSize ? Math.ceil( total / chunkSize ) : 1,

                start = 0,

                index = 0,

                len;

    
            while ( index < chunks ) {

                len = Math.min( chunkSize, total - start );

    
                pending.push({

                    file: file,

                    start: start,

                    end: chunkSize ? (start + len) : total,

                    total: total,

                    chunks: chunks,

                    chunk: index++

                });

                start += len;

            }

    
            file.blocks = pending.concat();

            file.remaning = pending.length;

    
            return {

                file: file,

    
                has: function() {

                    return !!pending.length;

                },

    
                fetch: function() {

                    return pending.shift();

                }

            };

        }

    
        Uploader.register({

            'start-upload': 'start',

            'stop-upload': 'stop',

            'skip-file': 'skipFile',

            'is-in-progress': 'isInProgress'

        }, {

    
            init: function() {

                var owner = this.owner;

    
                this.runing = false;

    
                // 记录当前正在传的数据，跟threads相关

                this.pool = [];

    
                // 缓存即将上传的文件。

                this.pending = [];

    
                // 跟踪还有多少分片没有完成上传。

                this.remaning = 0;

                this.__tick = Base.bindFn( this._tick, this );

    
                owner.on( 'uploadComplete', function( file ) {

                    // 把其他块取消了。

                    file.blocks && $.each( file.blocks, function( _, v ) {

                        v.transport && (v.transport.abort(), v.transport.destroy());

                        delete v.transport;

                    });

    
                    delete file.blocks;

                    delete file.remaning;

                });

            },

    
            /**

             * @event startUpload

             * @description 当开始上传流程时触发。

             * @for  Uploader

             */

    
            /**

             * 开始上传。此方法可以从初始状态调用开始上传流程，也可以从暂停状态调用，继续上传流程。

             * @grammar upload() => undefined

             * @method upload

             * @for  Uploader

             */

            start: function() {

                var me = this;

    
                // 移出invalid的文件

                $.each( me.request( 'get-files', Status.INVALID ), function() {

                    me.request( 'remove-file', this );

                });

    
                if ( me.runing ) {

                    return;

                }

    
                me.runing = true;

    
                // 如果有暂停的，则续传

                $.each( me.pool, function( _, v ) {

                    var file = v.file;

    
                    if ( file.getStatus() === Status.INTERRUPT ) {

                        file.setStatus( Status.PROGRESS );

                        me._trigged = false;

                        v.transport && v.transport.send();

                    }

                });

    
                me._trigged = false;

                me.owner.trigger('startUpload');

                Base.nextTick( me.__tick );

            },

    
            /**

             * @event stopUpload

             * @description 当开始上传流程暂停时触发。

             * @for  Uploader

             */

    
            /**

             * 暂停上传。第一个参数为是否中断上传当前正在上传的文件。

             * @grammar stop() => undefined

             * @grammar stop( true ) => undefined

             * @method stop

             * @for  Uploader

             */

            stop: function( interrupt ) {

                var me = this;

    
                if ( me.runing === false ) {

                    return;

                }

    
                me.runing = false;

    
                interrupt && $.each( me.pool, function( _, v ) {

                    v.transport && v.transport.abort();

                    v.file.setStatus( Status.INTERRUPT );

                });

    
                me.owner.trigger('stopUpload');

            },

    
            /**

             * 判断`Uplaode`r是否正在上传中。

             * @grammar isInProgress() => Boolean

             * @method isInProgress

             * @for  Uploader

             */

            isInProgress: function() {

                return !!this.runing;

            },

    
            getStats: function() {

                return this.request('get-stats');

            },

    
            /**

             * 掉过一个文件上传，直接标记指定文件为已上传状态。

             * @grammar skipFile( file ) => undefined

             * @method skipFile

             * @for  Uploader

             */

            skipFile: function( file, status ) {

                file = this.request( 'get-file', file );

    
                file.setStatus( status || Status.COMPLETE );

                file.skipped = true;

    
                // 如果正在上传。

                file.blocks && $.each( file.blocks, function( _, v ) {

                    var _tr = v.transport;

    
                    if ( _tr ) {

                        _tr.abort();

                        _tr.destroy();

                        delete v.transport;

                    }

                });

    
                this.owner.trigger( 'uploadSkip', file );

            },

    
            /**

             * @event uploadFinished

             * @description 当所有文件上传结束时触发。

             * @for  Uploader

             */

            _tick: function() {

                var me = this,

                    opts = me.options,

                    fn, val;

    
                // 上一个promise还没有结束，则等待完成后再执行。

                if ( me._promise ) {

                    return me._promise.always( me.__tick );

                }

    
                // 还有位置，且还有文件要处理的话。

                if ( me.pool.length < opts.threads && (val = me._nextBlock()) ) {

                    me._trigged = false;

    
                    fn = function( val ) {

                        me._promise = null;

    
                        // 有可能是reject过来的，所以要检测val的类型。

                        val && val.file && me._startSend( val );

                        Base.nextTick( me.__tick );

                    };

    
                    me._promise = isPromise( val ) ? val.always( fn ) : fn( val );

    
                // 没有要上传的了，且没有正在传输的了。

                } else if ( !me.remaning && !me.getStats().numOfQueue ) {

                    me.runing = false;

    
                    me._trigged || Base.nextTick(function() {

                        me.owner.trigger('uploadFinished');

                    });

                    me._trigged = true;

                }

            },

    
            _nextBlock: function() {

                var me = this,

                    act = me._act,

                    opts = me.options,

                    next, done;

    
                // 如果当前文件还有没有需要传输的，则直接返回剩下的。

                if ( act && act.has() &&

                        act.file.getStatus() === Status.PROGRESS ) {

    
                    // 是否提前准备下一个文件

                    if ( opts.prepareNextFile && !me.pending.length ) {

                        me._prepareNextFile();

                    }

    
                    return act.fetch();

    
                // 否则，如果正在运行，则准备下一个文件，并等待完成后返回下个分片。

                } else if ( me.runing ) {

    
                    // 如果缓存中有，则直接在缓存中取，没有则去queue中取。

                    if ( !me.pending.length && me.getStats().numOfQueue ) {

                        me._prepareNextFile();

                    }

    
                    next = me.pending.shift();

                    done = function( file ) {

                        if ( !file ) {

                            return null;

                        }

    
                        act = CuteFile( file, opts.chunked ? opts.chunkSize : 0 );

                        me._act = act;

                        return act.fetch();

                    };

    
                    // 文件可能还在prepare中，也有可能已经完全准备好了。

                    return isPromise( next ) ?

                            next[ next.pipe ? 'pipe' : 'then']( done ) :

                            done( next );

                }

            },

    
    
            /**

             * @event uploadStart

             * @param {File} file File对象

             * @description 某个文件开始上传前触发，一个文件只会触发一次。

             * @for  Uploader

             */

            _prepareNextFile: function() {

                var me = this,

                    file = me.request('fetch-file'),

                    pending = me.pending,

                    promise;

    
                if ( file ) {

                    promise = me.request( 'before-send-file', file, function() {

    
                        // 有可能文件被skip掉了。文件被skip掉后，状态坑定不是Queued.

                        if ( file.getStatus() === Status.QUEUED ) {

                            me.owner.trigger( 'uploadStart', file );

                            file.setStatus( Status.PROGRESS );

                            return file;

                        }

    
                        return me._finishFile( file );

                    });

    
                    // 如果还在pending中，则替换成文件本身。

                    promise.done(function() {

                        var idx = $.inArray( promise, pending );

    
                        ~idx && pending.splice( idx, 1, file );

                    });

    
                    // befeore-send-file的钩子就有错误发生。

                    promise.fail(function( reason ) {

                        file.setStatus( Status.ERROR, reason );

                        me.owner.trigger( 'uploadError', file, reason );

                        me.owner.trigger( 'uploadComplete', file );

                    });

    
                    pending.push( promise );

                }

            },

    
            // 让出位置了，可以让其他分片开始上传

            _popBlock: function( block ) {

                var idx = $.inArray( block, this.pool );

    
                this.pool.splice( idx, 1 );

                block.file.remaning--;

                this.remaning--;

            },

    
            // 开始上传，可以被掉过。如果promise被reject了，则表示跳过此分片。

            _startSend: function( block ) {

                var me = this,

                    file = block.file,

                    promise;

    
                me.pool.push( block );

                me.remaning++;

    
                // 如果没有分片，则直接使用原始的。

                // 不会丢失content-type信息。

                block.blob = block.chunks === 1 ? file.source :

                        file.source.slice( block.start, block.end );

    
                // hook, 每个分片发送之前可能要做些异步的事情。

                promise = me.request( 'before-send', block, function() {

    
                    // 有可能文件已经上传出错了，所以不需要再传输了。

                    if ( file.getStatus() === Status.PROGRESS ) {

                        me._doSend( block );

                    } else {

                        me._popBlock( block );

                        Base.nextTick( me.__tick );

                    }

                });

    
                // 如果为fail了，则跳过此分片。

                promise.fail(function() {

                    if ( file.remaning === 1 ) {

                        me._finishFile( file ).always(function() {

                            block.percentage = 1;

                            me._popBlock( block );

                            me.owner.trigger( 'uploadComplete', file );

                            Base.nextTick( me.__tick );

                        });

                    } else {

                        block.percentage = 1;

                        me._popBlock( block );

                        Base.nextTick( me.__tick );

                    }

                });

            },

    
    
            /**

             * @event uploadBeforeSend

             * @param {Object} object

             * @param {Object} data 默认的上传参数，可以扩展此对象来控制上传参数。

             * @description 当某个文件的分块在发送前触发，主要用来询问是否要添加附带参数，大文件在开起分片上传的前提下此事件可能会触发多次。

             * @for  Uploader

             */

    
            /**

             * @event uploadAccept

             * @param {Object} object

             * @param {Object} ret 服务端的返回数据，json格式，如果服务端不是json格式，从ret._raw中取数据，自行解析。

             * @description 当某个文件上传到服务端响应后，会派送此事件来询问服务端响应是否有效。如果此事件handler返回值为`false`, 则此文件将派送`server`类型的`uploadError`事件。

             * @for  Uploader

             */

    
            /**

             * @event uploadProgress

             * @param {File} file File对象

             * @param {Number} percentage 上传进度

             * @description 上传过程中触发，携带上传进度。

             * @for  Uploader

             */

    
    
            /**

             * @event uploadError

             * @param {File} file File对象

             * @param {String} reason 出错的code

             * @description 当文件上传出错时触发。

             * @for  Uploader

             */

    
            /**

             * @event uploadSuccess

             * @param {File} file File对象

             * @param {Object} response 服务端返回的数据

             * @description 当文件上传成功时触发。

             * @for  Uploader

             */

    
            /**

             * @event uploadComplete

             * @param {File} [file] File对象

             * @description 不管成功或者失败，文件上传完成时触发。

             * @for  Uploader

             */

    
            // 做上传操作。

            _doSend: function( block ) {

                var me = this,

                    owner = me.owner,

                    opts = me.options,

                    file = block.file,

                    tr = new Transport( opts ),

                    data = $.extend({}, opts.formData ),

                    headers = $.extend({}, opts.headers ),

                    requestAccept, ret;

    
                block.transport = tr;

    
                tr.on( 'destroy', function() {

                    delete block.transport;

                    me._popBlock( block );

                    Base.nextTick( me.__tick );

                });

    
                // 广播上传进度。以文件为单位。

                tr.on( 'progress', function( percentage ) {

                    var totalPercent = 0,

                        uploaded = 0;

    
                    // 可能没有abort掉，progress还是执行进来了。

                    // if ( !file.blocks ) {

                    //     return;

                    // }

    
                    totalPercent = block.percentage = percentage;

    
                    if ( block.chunks > 1 ) {    // 计算文件的整体速度。

                        $.each( file.blocks, function( _, v ) {

                            uploaded += (v.percentage || 0) * (v.end - v.start);

                        });

    
                        totalPercent = uploaded / file.size;

                    }

    
                    owner.trigger( 'uploadProgress', file, totalPercent || 0 );

                });

    
                // 用来询问，是否返回的结果是有错误的。

                requestAccept = function( reject ) {

                    var fn;

    
                    ret = tr.getResponseAsJson() || {};

                    ret._raw = tr.getResponse();

                    fn = function( value ) {

                        reject = value;

                    };

    
                    // 服务端响应了，不代表成功了，询问是否响应正确。

                    if ( !owner.trigger( 'uploadAccept', block, ret, fn ) ) {

                        reject = reject || 'server';

                    }

    
                    return reject;

                };

    
                // 尝试重试，然后广播文件上传出错。

                tr.on( 'error', function( type, flag ) {

                    block.retried = block.retried || 0;

    
                    // 自动重试

                    if ( block.chunks > 1 && ~'http,abort'.indexOf( type ) &&

                            block.retried < opts.chunkRetry ) {

    
                        block.retried++;

                        tr.send();

    
                    } else {

    
                        // http status 500 ~ 600

                        if ( !flag && type === 'server' ) {

                            type = requestAccept( type );

                        }

    
                        file.setStatus( Status.ERROR, type );

                        owner.trigger( 'uploadError', file, type );

                        owner.trigger( 'uploadComplete', file );

                    }

                });

    
                // 上传成功

                tr.on( 'load', function() {

                    var reason;

    
                    // 如果非预期，转向上传出错。

                    if ( (reason = requestAccept()) ) {

                        tr.trigger( 'error', reason, true );

                        return;

                    }

    
                    // 全部上传完成。

                    if ( file.remaning === 1 ) {

                        me._finishFile( file, ret );

                    } else {

                        tr.destroy();

                    }

                });

    
                // 配置默认的上传字段。

                data = $.extend( data, {

                    id: file.id,

                    name: file.name,

                    type: file.type,

                    lastModifiedDate: file.lastModifiedDate,

                    size: file.size

                });

    
                block.chunks > 1 && $.extend( data, {

                    chunks: block.chunks,

                    chunk: block.chunk

                });

    
                // 在发送之间可以添加字段什么的。。。

                // 如果默认的字段不够使用，可以通过监听此事件来扩展

                owner.trigger( 'uploadBeforeSend', block, data, headers );

    
                // 开始发送。

                tr.appendBlob( opts.fileVal, block.blob, file.name );

                tr.append( data );

                tr.setRequestHeader( headers );

                tr.send();

            },

    
            // 完成上传。

            _finishFile: function( file, ret, hds ) {

                var owner = this.owner;

    
                return owner

                        .request( 'after-send-file', arguments, function() {

                            file.setStatus( Status.COMPLETE );

                            owner.trigger( 'uploadSuccess', file, ret, hds );

                        })

                        .fail(function( reason ) {

    
                            // 如果外部已经标记为invalid什么的，不再改状态。

                            if ( file.getStatus() === Status.PROGRESS ) {

                                file.setStatus( Status.ERROR, reason );

                            }

    
                            owner.trigger( 'uploadError', file, reason );

                        })

                        .always(function() {

                            owner.trigger( 'uploadComplete', file );

                        });

            }

    
        });

    });

    /**

     * @fileOverview 各种验证，包括文件总大小是否超出、单文件是否超出和文件是否重复。

     */

    
    define('widgets/validator',[

        'base',

        'uploader',

        'file',

        'widgets/widget'

    ], function( Base, Uploader, WUFile ) {

    
        var $ = Base.$,

            validators = {},

            api;

    
        /**

         * @event error

         * @param {String} type 错误类型。

         * @description 当validate不通过时，会以派送错误事件的形式通知调用者。通过`upload.on('error', handler)`可以捕获到此类错误，目前有以下错误会在特定的情况下派送错来。

         *

         * * `Q_EXCEED_NUM_LIMIT` 在设置了`fileNumLimit`且尝试给`uploader`添加的文件数量超出这个值时派送。

         * * `Q_EXCEED_SIZE_LIMIT` 在设置了`Q_EXCEED_SIZE_LIMIT`且尝试给`uploader`添加的文件总大小超出这个值时派送。

         * @for  Uploader

         */

    
        // 暴露给外面的api

        api = {

    
            // 添加验证器

            addValidator: function( type, cb ) {

                validators[ type ] = cb;

            },

    
            // 移除验证器

            removeValidator: function( type ) {

                delete validators[ type ];

            }

        };

    
        // 在Uploader初始化的时候启动Validators的初始化

        Uploader.register({

            init: function() {

                var me = this;

                $.each( validators, function() {

                    this.call( me.owner );

                });

            }

        });

    
        /**

         * @property {int} [fileNumLimit=undefined]

         * @namespace options

         * @for Uploader

         * @description 验证文件总数量, 超出则不允许加入队列。

         */

        api.addValidator( 'fileNumLimit', function() {

            var uploader = this,

                opts = uploader.options,

                count = 0,

                max = opts.fileNumLimit >> 0,

                flag = true;

    
            if ( !max ) {

                return;

            }

    
            uploader.on( 'beforeFileQueued', function( file ) {

    
                if ( count >= max && flag ) {

                    flag = false;

                    this.trigger( 'error', 'Q_EXCEED_NUM_LIMIT', max, file );

                    setTimeout(function() {

                        flag = true;

                    }, 1 );

                }

    
                return count >= max ? false : true;

            });

    
            uploader.on( 'fileQueued', function() {

                count++;

            });

    
            uploader.on( 'fileDequeued', function() {

                count--;

            });

    
            uploader.on( 'uploadFinished', function() {

                count = 0;

            });

        });

    
    
        /**

         * @property {int} [fileSizeLimit=undefined]

         * @namespace options

         * @for Uploader

         * @description 验证文件总大小是否超出限制, 超出则不允许加入队列。

         */

        api.addValidator( 'fileSizeLimit', function() {

            var uploader = this,

                opts = uploader.options,

                count = 0,

                max = opts.fileSizeLimit >> 0,

                flag = true;

    
            if ( !max ) {

                return;

            }

    
            uploader.on( 'beforeFileQueued', function( file ) {

                var invalid = count + file.size > max;

    
                if ( invalid && flag ) {

                    flag = false;

                    this.trigger( 'error', 'Q_EXCEED_SIZE_LIMIT', max, file );

                    setTimeout(function() {

                        flag = true;

                    }, 1 );

                }

    
                return invalid ? false : true;

            });

    
            uploader.on( 'fileQueued', function( file ) {

                count += file.size;

            });

    
            uploader.on( 'fileDequeued', function( file ) {

                count -= file.size;

            });

    
            uploader.on( 'uploadFinished', function() {

                count = 0;

            });

        });

    
        /**

         * @property {int} [fileSingleSizeLimit=undefined]

         * @namespace options

         * @for Uploader

         * @description 验证单个文件大小是否超出限制, 超出则不允许加入队列。

         */

        api.addValidator( 'fileSingleSizeLimit', function() {

            var uploader = this,

                opts = uploader.options,

                max = opts.fileSingleSizeLimit;

    
            if ( !max ) {

                return;

            }

    
            uploader.on( 'beforeFileQueued', function( file ) {

    
                if ( file.size > max ) {

                    file.setStatus( WUFile.Status.INVALID, 'exceed_size' );

                    this.trigger( 'error', 'F_EXCEED_SIZE', file );

                    return false;

                }

    
            });

    
        });

    
        /**

         * @property {int} [duplicate=undefined]

         * @namespace options

         * @for Uploader

         * @description 去重， 根据文件名字、文件大小和最后修改时间来生成hash Key.

         */

        api.addValidator( 'duplicate', function() {

            var uploader = this,

                opts = uploader.options,

                mapping = {};

    
            if ( opts.duplicate ) {

                return;

            }

    
            function hashString( str ) {

                var hash = 0,

                    i = 0,

                    len = str.length,

                    _char;

    
                for ( ; i < len; i++ ) {

                    _char = str.charCodeAt( i );

                    hash = _char + (hash << 6) + (hash << 16) - hash;

                }

    
                return hash;

            }

    
            uploader.on( 'beforeFileQueued', function( file ) {

                var hash = file.__hash || (file.__hash = hashString( file.name +

                        file.size + file.lastModifiedDate ));

    
                // 已经重复了

                if ( mapping[ hash ] ) {

                    this.trigger( 'error', 'F_DUPLICATE', file );

                    return false;

                }

            });

    
            uploader.on( 'fileQueued', function( file ) {

                var hash = file.__hash;

    
                hash && (mapping[ hash ] = true);

            });

    
            uploader.on( 'fileDequeued', function( file ) {

                var hash = file.__hash;

    
                hash && (delete mapping[ hash ]);

            });

        });

    
        return api;

    });

    
    /**

     * @fileOverview Runtime管理器，负责Runtime的选择, 连接

     */

    define('runtime/compbase',[],function() {

    
        function CompBase( owner, runtime ) {

    
            this.owner = owner;

            this.options = owner.options;

    
            this.getRuntime = function() {

                return runtime;

            };

    
            this.getRuid = function() {

                return runtime.uid;

            };

    
            this.trigger = function() {

                return owner.trigger.apply( owner, arguments );

            };

        }

    
        return CompBase;

    });

    /**

     * @fileOverview Html5Runtime

     */

    define('runtime/html5/runtime',[

        'base',

        'runtime/runtime',

        'runtime/compbase'

    ], function( Base, Runtime, CompBase ) {

    
        var type = 'html5',

            components = {};

    
        function Html5Runtime() {

            var pool = {},

                me = this,

                destory = this.destory;

    
            Runtime.apply( me, arguments );

            me.type = type;

    
    
            // 这个方法的调用者，实际上是RuntimeClient

            me.exec = function( comp, fn/*, args...*/) {

                var client = this,

                    uid = client.uid,

                    args = Base.slice( arguments, 2 ),

                    instance;

    
                if ( components[ comp ] ) {

                    instance = pool[ uid ] = pool[ uid ] ||

                            new components[ comp ]( client, me );

    
                    if ( instance[ fn ] ) {

                        return instance[ fn ].apply( instance, args );

                    }

                }

            };

    
            me.destory = function() {

                // @todo 删除池子中的所有实例

                return destory && destory.apply( this, arguments );

            };

        }

    
        Base.inherits( Runtime, {

            constructor: Html5Runtime,

    
            // 不需要连接其他程序，直接执行callback

            init: function() {

                var me = this;

                setTimeout(function() {

                    me.trigger('ready');

                }, 1 );

            }

    
        });

    
        // 注册Components

        Html5Runtime.register = function( name, component ) {

            var klass = components[ name ] = Base.inherits( CompBase, component );

            return klass;

        };

    
        // 注册html5运行时。

        // 只有在支持的前提下注册。

        if ( window.Blob && window.FileReader && window.DataView ) {

            Runtime.addRuntime( type, Html5Runtime );

        }

    
        return Html5Runtime;

    });

    /**

     * @fileOverview Blob Html实现

     */

    define('runtime/html5/blob',[

        'runtime/html5/runtime',

        'lib/blob'

    ], function( Html5Runtime, Blob ) {

    
        return Html5Runtime.register( 'Blob', {

            slice: function( start, end ) {

                var blob = this.owner.source,

                    slice = blob.slice || blob.webkitSlice || blob.mozSlice;

    
                blob = slice.call( blob, start, end );

    
                return new Blob( this.getRuid(), blob );

            }

        });

    });

    /**

     * @fileOverview FilePaste

     */

    define('runtime/html5/dnd',[

        'base',

        'runtime/html5/runtime',

        'lib/file'

    ], function( Base, Html5Runtime, File ) {

    
        var $ = Base.$,

            prefix = 'webuploader-dnd-';

    
        return Html5Runtime.register( 'DragAndDrop', {

            init: function() {

                var elem = this.elem = this.options.container;

    
                this.dragEnterHandler = Base.bindFn( this._dragEnterHandler, this );

                this.dragOverHandler = Base.bindFn( this._dragOverHandler, this );

                this.dragLeaveHandler = Base.bindFn( this._dragLeaveHandler, this );

                this.dropHandler = Base.bindFn( this._dropHandler, this );

                this.dndOver = false;

    
                elem.on( 'dragenter', this.dragEnterHandler );

                elem.on( 'dragover', this.dragOverHandler );

                elem.on( 'dragleave', this.dragLeaveHandler );

                elem.on( 'drop', this.dropHandler );

    
                if ( this.options.disableGlobalDnd ) {

                    $( document ).on( 'dragover', this.dragOverHandler );

                    $( document ).on( 'drop', this.dropHandler );

                }

            },

    
            _dragEnterHandler: function( e ) {

                var me = this,

                    denied = me._denied || false,

                    items;

    
                e = e.originalEvent || e;

    
                if ( !me.dndOver ) {

                    me.dndOver = true;

    
                    // 注意只有 chrome 支持。

                    items = e.dataTransfer.items;

    
                    if ( items && items.length ) {

                        me._denied = denied = !me.trigger( 'accept', items );

                    }

    
                    me.elem.addClass( prefix + 'over' );

                    me.elem[ denied ? 'addClass' :

                            'removeClass' ]( prefix + 'denied' );

                }

    
    
                e.dataTransfer.dropEffect = denied ? 'none' : 'copy';

    
                return false;

            },

    
            _dragOverHandler: function( e ) {

                // 只处理框内的。

                var parentElem = this.elem.parent().get( 0 );

                if ( parentElem && !$.contains( parentElem, e.currentTarget ) ) {

                    return false;

                }

    
                clearTimeout( this._leaveTimer );

                this._dragEnterHandler.call( this, e );

    
                return false;

            },

    
            _dragLeaveHandler: function() {

                var me = this,

                    handler;

    
                handler = function() {

                    me.dndOver = false;

                    me.elem.removeClass( prefix + 'over ' + prefix + 'denied' );

                };

    
                clearTimeout( me._leaveTimer );

                me._leaveTimer = setTimeout( handler, 100 );

                return false;

            },

    
            _dropHandler: function( e ) {

                var me = this,

                    ruid = me.getRuid(),

                    parentElem = me.elem.parent().get( 0 );

    
                // 只处理框内的。

                if ( parentElem && !$.contains( parentElem, e.currentTarget ) ) {

                    return false;

                }

    
                me._getTansferFiles( e, function( results ) {

                    me.trigger( 'drop', $.map( results, function( file ) {

                        return new File( ruid, file );

                    }) );

                });

    
                me.dndOver = false;

                me.elem.removeClass( prefix + 'over' );

                return false;

            },

    
            // 如果传入 callback 则去查看文件夹，否则只管当前文件夹。

            _getTansferFiles: function( e, callback ) {

                var results  = [],

                    promises = [],

                    items, files, dataTransfer, file, item, i, len, canAccessFolder;

    
                e = e.originalEvent || e;

    
                dataTransfer = e.dataTransfer;

                items = dataTransfer.items;

                files = dataTransfer.files;

    
                canAccessFolder = !!(items && items[ 0 ].webkitGetAsEntry);

    
                for ( i = 0, len = files.length; i < len; i++ ) {

                    file = files[ i ];

                    item = items && items[ i ];

    
                    if ( canAccessFolder && item.webkitGetAsEntry().isDirectory ) {

    
                        promises.push( this._traverseDirectoryTree(

                                item.webkitGetAsEntry(), results ) );

                    } else {

                        results.push( file );

                    }

                }

    
                Base.when.apply( Base, promises ).done(function() {

    
                    if ( !results.length ) {

                        return;

                    }

    
                    callback( results );

                });

            },

    
            _traverseDirectoryTree: function( entry, results ) {

                var deferred = Base.Deferred(),

                    me = this;

    
                if ( entry.isFile ) {

                    entry.file(function( file ) {

                        results.push( file );

                        deferred.resolve();

                    });

                } else if ( entry.isDirectory ) {

                    entry.createReader().readEntries(function( entries ) {

                        var len = entries.length,

                            promises = [],

                            arr = [],    // 为了保证顺序。

                            i;

    
                        for ( i = 0; i < len; i++ ) {

                            promises.push( me._traverseDirectoryTree(

                                    entries[ i ], arr ) );

                        }

    
                        Base.when.apply( Base, promises ).then(function() {

                            results.push.apply( results, arr );

                            deferred.resolve();

                        }, deferred.reject );

                    });

                }

    
                return deferred.promise();

            },

    
            destroy: function() {

                var elem = this.elem;

    
                elem.off( 'dragenter', this.dragEnterHandler );

                elem.off( 'dragover', this.dragEnterHandler );

                elem.off( 'dragleave', this.dragLeaveHandler );

                elem.off( 'drop', this.dropHandler );

    
                if ( this.options.disableGlobalDnd ) {

                    $( document ).off( 'dragover', this.dragOverHandler );

                    $( document ).off( 'drop', this.dropHandler );

                }

            }

        });

    });

    
    /**

     * @fileOverview FilePaste

     */

    define('runtime/html5/filepaste',[

        'base',

        'runtime/html5/runtime',

        'lib/file'

    ], function( Base, Html5Runtime, File ) {

    
        return Html5Runtime.register( 'FilePaste', {

            init: function() {

                var opts = this.options,

                    elem = this.elem = opts.container,

                    accept = '.*',

                    arr, i, len, item;

    
                // accetp的mimeTypes中生成匹配正则。

                if ( opts.accept ) {

                    arr = [];

    
                    for ( i = 0, len = opts.accept.length; i < len; i++ ) {

                        item = opts.accept[ i ].mimeTypes;

                        item && arr.push( item );

                    }

    
                    if ( arr.length ) {

                        accept = arr.join(',');

                        accept = accept.replace( /,/g, '|' ).replace( /\*/g, '.*' );

                    }

                }

                this.accept = accept = new RegExp( accept, 'i' );

                this.hander = Base.bindFn( this._pasteHander, this );

                elem.on( 'paste', this.hander );

            },

    
            _pasteHander: function( e ) {

                var allowed = [],

                    ruid = this.getRuid(),

                    items, item, blob, i, len;

    
                e = e.originalEvent || e;

                items = e.clipboardData.items;

    
                for ( i = 0, len = items.length; i < len; i++ ) {

                    item = items[ i ];

    
                    if ( item.kind !== 'file' || !(blob = item.getAsFile()) ) {

                        continue;

                    }

    
                    allowed.push( new File( ruid, blob ) );

                }

    
                if ( allowed.length ) {

                    // 不阻止非文件粘贴（文字粘贴）的事件冒泡

                    e.preventDefault();

                    e.stopPropagation();

                    this.trigger( 'paste', allowed );

                }

            },

    
            destroy: function() {

                this.elem.off( 'paste', this.hander );

            }

        });

    });

    
    /**

     * @fileOverview FilePicker

     */

    define('runtime/html5/filepicker',[

        'base',

        'runtime/html5/runtime'

    ], function( Base, Html5Runtime ) {

    
        var $ = Base.$;

    
        return Html5Runtime.register( 'FilePicker', {

            init: function() {

                var container = this.getRuntime().getContainer(),

                    me = this,

                    owner = me.owner,

                    opts = me.options,

                    lable = $( document.createElement('label') ),

                    input = $( document.createElement('input') ),

                    arr, i, len, mouseHandler;

    
                input.attr( 'type', 'file' );

                input.attr( 'name', opts.name );

                input.addClass('webuploader-element-invisible');

    
                lable.on( 'click', function() {

                    input.trigger('click');

                });

    
                lable.css({

                    opacity: 0,

                    width: '100%',

                    height: '100%',

                    display: 'block',

                    cursor: 'pointer',

                    background: '#ffffff'

                });

    
                if ( opts.multiple ) {

                    input.attr( 'multiple', 'multiple' );

                }

    
                // @todo Firefox不支持单独指定后缀

                if ( opts.accept && opts.accept.length > 0 ) {

                    arr = [];

    
                    for ( i = 0, len = opts.accept.length; i < len; i++ ) {

                        arr.push( opts.accept[ i ].mimeTypes );

                    }

    
                    input.attr( 'accept', arr.join(',') );

                }

    
                container.append( input );

                container.append( lable );

    
                mouseHandler = function( e ) {

                    owner.trigger( e.type );

                };

    
                input.on( 'change', function( e ) {

                    var fn = arguments.callee,

                        clone;

    
                    me.files = e.target.files;

    
                    // reset input

                    clone = this.cloneNode( true );

                    this.parentNode.replaceChild( clone, this );

    
                    input.off();

                    input = $( clone ).on( 'change', fn )

                            .on( 'mouseenter mouseleave', mouseHandler );

    
                    owner.trigger('change');

                });

    
                lable.on( 'mouseenter mouseleave', mouseHandler );

    
            },

    
    
            getFiles: function() {

                return this.files;

            },

    
            destroy: function() {

                // todo

            }

        });

    });

    /**

     * @fileOverview Transport

     * @todo 支持chunked传输，优势：

     * 可以将大文件分成小块，挨个传输，可以提高大文件成功率，当失败的时候，也只需要重传那小部分，

     * 而不需要重头再传一次。另外断点续传也需要用chunked方式。

     */

    define('runtime/html5/transport',[

        'base',

        'runtime/html5/runtime'

    ], function( Base, Html5Runtime ) {

    
        var noop = Base.noop,

            $ = Base.$;

    
        return Html5Runtime.register( 'Transport', {

            init: function() {

                this._status = 0;

                this._response = null;

            },

    
            send: function() {

                var owner = this.owner,

                    opts = this.options,

                    xhr = this._initAjax(),

                    blob = owner._blob,

                    server = opts.server,

                    formData, binary, fr;

    
                if ( opts.sendAsBinary ) {

                    server += (/\?/.test( server ) ? '&' : '?') +

                            $.param( owner._formData );

    
                    binary = blob.getSource();

                } else {

                    formData = new FormData();

                    $.each( owner._formData, function( k, v ) {

                        formData.append( k, v );

                    });

    
                    formData.append( opts.fileVal, blob.getSource(),

                            opts.filename || owner._formData.name || '' );

                }

    
                if ( opts.withCredentials && 'withCredentials' in xhr ) {

                    xhr.open( opts.method, server, true );

                    xhr.withCredentials = true;

                } else {

                    xhr.open( opts.method, server );

                }

    
                this._setRequestHeader( xhr, opts.headers );

    
                if ( binary ) {

                    xhr.overrideMimeType('application/octet-stream');

    
                    // android直接发送blob会导致服务端接收到的是空文件。

                    // bug详情。

                    // https://code.google.com/p/android/issues/detail?id=39882

                    // 所以先用fileReader读取出来再通过arraybuffer的方式发送。

                    if ( Base.os.android ) {

                        fr = new FileReader();

    
                        fr.onload = function() {

                            xhr.send( this.result );

                            fr = fr.onload = null;

                        };

    
                        fr.readAsArrayBuffer( binary );

                    } else {

                        xhr.send( binary );

                    }

                } else {

                    xhr.send( formData );

                }

            },

    
            getResponse: function() {

                return this._response;

            },

    
            getResponseAsJson: function() {

                return this._parseJson( this._response );

            },

    
            getStatus: function() {

                return this._status;

            },

    
            abort: function() {

                var xhr = this._xhr;

    
                if ( xhr ) {

                    xhr.upload.onprogress = noop;

                    xhr.onreadystatechange = noop;

                    xhr.abort();

    
                    this._xhr = xhr = null;

                }

            },

    
            destroy: function() {

                this.abort();

            },

    
            _initAjax: function() {

                var me = this,

                    xhr = new XMLHttpRequest(),

                    opts = this.options;

    
                if ( opts.withCredentials && !('withCredentials' in xhr) &&

                        typeof XDomainRequest !== 'undefined' ) {

                    xhr = new XDomainRequest();

                }

    
                xhr.upload.onprogress = function( e ) {

                    var percentage = 0;

    
                    if ( e.lengthComputable ) {

                        percentage = e.loaded / e.total;

                    }

    
                    return me.trigger( 'progress', percentage );

                };

    
                xhr.onreadystatechange = function() {

    
                    if ( xhr.readyState !== 4 ) {

                        return;

                    }

    
                    xhr.upload.onprogress = noop;

                    xhr.onreadystatechange = noop;

                    me._xhr = null;

                    me._status = xhr.status;

    
                    if ( xhr.status >= 200 && xhr.status < 300 ) {

                        me._response = xhr.responseText;

                        return me.trigger('load');

                    } else if ( xhr.status >= 500 && xhr.status < 600 ) {

                        me._response = xhr.responseText;

                        return me.trigger( 'error', 'server' );

                    }

    
    
                    return me.trigger( 'error', me._status ? 'http' : 'abort' );

                };

    
                me._xhr = xhr;

                return xhr;

            },

    
            _setRequestHeader: function( xhr, headers ) {

                $.each( headers, function( key, val ) {

                    xhr.setRequestHeader( key, val );

                });

            },

    
            _parseJson: function( str ) {

                var json;

    
                try {

                    json = JSON.parse( str );

                } catch ( ex ) {

                    json = {};

                }

    
                return json;

            }

        });

    });

    /**

     * @fileOverview FlashRuntime

     */

    define('runtime/flash/runtime',[

        'base',

        'runtime/runtime',

        'runtime/compbase'

    ], function( Base, Runtime, CompBase ) {

    
        var $ = Base.$,

            type = 'flash',

            components = {};

    
    
        function getFlashVersion() {

            var version;

    
            try {

                version = navigator.plugins[ 'Shockwave Flash' ];

                version = version.description;

            } catch ( ex ) {

                try {

                    version = new ActiveXObject('ShockwaveFlash.ShockwaveFlash')

                            .GetVariable('$version');

                } catch ( ex2 ) {

                    version = '0.0';

                }

            }

            version = version.match( /\d+/g );

            return parseFloat( version[ 0 ] + '.' + version[ 1 ], 10 );

        }

    
        function FlashRuntime() {

            var pool = {},

                clients = {},

                destory = this.destory,

                me = this,

                jsreciver = Base.guid('webuploader_');

    
            Runtime.apply( me, arguments );

            me.type = type;

    
    
            // 这个方法的调用者，实际上是RuntimeClient

            me.exec = function( comp, fn/*, args...*/ ) {

                var client = this,

                    uid = client.uid,

                    args = Base.slice( arguments, 2 ),

                    instance;

    
                clients[ uid ] = client;

    
                if ( components[ comp ] ) {

                    if ( !pool[ uid ] ) {

                        pool[ uid ] = new components[ comp ]( client, me );

                    }

    
                    instance = pool[ uid ];

    
                    if ( instance[ fn ] ) {

                        return instance[ fn ].apply( instance, args );

                    }

                }

    
                return me.flashExec.apply( client, arguments );

            };

    
            function handler( evt, obj ) {

                var type = evt.type || evt,

                    parts, uid;

    
                parts = type.split('::');

                uid = parts[ 0 ];

                type = parts[ 1 ];

    
                // console.log.apply( console, arguments );

    
                if ( type === 'Ready' && uid === me.uid ) {

                    me.trigger('ready');

                } else if ( clients[ uid ] ) {

                    clients[ uid ].trigger( type.toLowerCase(), evt, obj );

                }

    
                // Base.log( evt, obj );

            }

    
            // flash的接受器。

            window[ jsreciver ] = function() {

                var args = arguments;

    
                // 为了能捕获得到。

                setTimeout(function() {

                    handler.apply( null, args );

                }, 1 );

            };

    
            this.jsreciver = jsreciver;

    
            this.destory = function() {

                // @todo 删除池子中的所有实例

                return destory && destory.apply( this, arguments );

            };

    
            this.flashExec = function( comp, fn ) {

                var flash = me.getFlash(),

                    args = Base.slice( arguments, 2 );

    
                return flash.exec( this.uid, comp, fn, args );

            };

    
            // @todo

        }

    
        Base.inherits( Runtime, {

            constructor: FlashRuntime,

    
            init: function() {

                var container = this.getContainer(),

                    opts = this.options,

                    html;

    
                // if not the minimal height, shims are not initialized

                // in older browsers (e.g FF3.6, IE6,7,8, Safari 4.0,5.0, etc)

                container.css({

                    position: 'absolute',

                    top: '-8px',

                    left: '-8px',

                    width: '9px',

                    height: '9px',

                    overflow: 'hidden'

                });

    
                // insert flash object

                html = '<object id="' + this.uid + '" type="application/' +

                        'x-shockwave-flash" data="' +  opts.swf + '" ';

    
                if ( Base.browser.ie ) {

                    html += 'classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" ';

                }

    
                html += 'width="100%" height="100%" style="outline:0">'  +

                    '<param name="movie" value="' + opts.swf + '" />' +

                    '<param name="flashvars" value="uid=' + this.uid +

                    '&jsreciver=' + this.jsreciver + '" />' +

                    '<param name="wmode" value="transparent" />' +

                    '<param name="allowscriptaccess" value="always" />' +

                '</object>';

    
                container.html( html );

            },

    
            getFlash: function() {

                if ( this._flash ) {

                    return this._flash;

                }

    
                this._flash = $( '#' + this.uid ).get( 0 );

                return this._flash;

            }

    
        });

    
        FlashRuntime.register = function( name, component ) {

            component = components[ name ] = Base.inherits( CompBase, $.extend({

    
                // @todo fix this later

                flashExec: function() {

                    var owner = this.owner,

                        runtime = this.getRuntime();

    
                    return runtime.flashExec.apply( owner, arguments );

                }

            }, component ) );

    
            return component;

        };

    
        if ( getFlashVersion() >= 11.4 ) {

            Runtime.addRuntime( type, FlashRuntime );

        }

    
        return FlashRuntime;

    });

    /**

     * @fileOverview FilePicker

     */

    define('runtime/flash/filepicker',[

        'base',

        'runtime/flash/runtime'

    ], function( Base, FlashRuntime ) {

        var $ = Base.$;

    
        return FlashRuntime.register( 'FilePicker', {

            init: function( opts ) {

                var copy = $.extend({}, opts ),

                    len, i;

    
                // 修复Flash再没有设置title的情况下无法弹出flash文件选择框的bug.

                len = copy.accept && copy.accept.length;

                for (  i = 0; i < len; i++ ) {

                    if ( !copy.accept[ i ].title ) {

                        copy.accept[ i ].title = 'Files';

                    }

                }

    
                delete copy.button;

                delete copy.container;

    
                this.flashExec( 'FilePicker', 'init', copy );

            },

    
            destroy: function() {

                // todo

            }

        });

    });

    /**

     * @fileOverview  Transport flash实现

     */

    define('runtime/flash/transport',[

        'base',

        'runtime/flash/runtime',

        'runtime/client'

    ], function( Base, FlashRuntime, RuntimeClient ) {

        var $ = Base.$;

    
        return FlashRuntime.register( 'Transport', {

            init: function() {

                this._status = 0;

                this._response = null;

                this._responseJson = null;

            },

    
            send: function() {

                var owner = this.owner,

                    opts = this.options,

                    xhr = this._initAjax(),

                    blob = owner._blob,

                    server = opts.server,

                    binary;

    
                xhr.connectRuntime( blob.ruid );

    
                if ( opts.sendAsBinary ) {

                    server += (/\?/.test( server ) ? '&' : '?') +

                            $.param( owner._formData );

    
                    binary = blob.uid;

                } else {

                    $.each( owner._formData, function( k, v ) {

                        xhr.exec( 'append', k, v );

                    });

    
                    xhr.exec( 'appendBlob', opts.fileVal, blob.uid,

                            opts.filename || owner._formData.name || '' );

                }

    
                this._setRequestHeader( xhr, opts.headers );

                xhr.exec( 'send', {

                    method: opts.method,

                    url: server

                }, binary );

            },

    
            getStatus: function() {

                return this._status;

            },

    
            getResponse: function() {

                return this._response;

            },

    
            getResponseAsJson: function() {

                return this._responseJson;

            },

    
            abort: function() {

                var xhr = this._xhr;

    
                if ( xhr ) {

                    xhr.exec('abort');

                    xhr.destroy();

                    this._xhr = xhr = null;

                }

            },

    
            destroy: function() {

                this.abort();

            },

    
            _initAjax: function() {

                var me = this,

                    xhr = new RuntimeClient('XMLHttpRequest');

    
                xhr.on( 'uploadprogress progress', function( e ) {

                    return me.trigger( 'progress', e.loaded / e.total );

                });

    
                xhr.on( 'load', function() {

                    var status = xhr.exec('getStatus'),

                        err = '';

    
                    xhr.off();

                    me._xhr = null;

    
                    if ( status >= 200 && status < 300 ) {

                        me._response = xhr.exec('getResponse');

                        me._responseJson = xhr.exec('getResponseAsJson');

                    } else if ( status >= 500 && status < 600 ) {

                        me._response = xhr.exec('getResponse');

                        me._responseJson = xhr.exec('getResponseAsJson');

                        err = 'server';

                    } else {

                        err = 'http';

                    }

    
                    xhr.destroy();

                    xhr = null;

    
                    return err ? me.trigger( 'error', err ) : me.trigger('load');

                });

    
                xhr.on( 'error', function() {

                    xhr.off();

                    me._xhr = null;

                    me.trigger( 'error', 'http' );

                });

    
                me._xhr = xhr;

                return xhr;

            },

    
            _setRequestHeader: function( xhr, headers ) {

                $.each( headers, function( key, val ) {

                    xhr.exec( 'setRequestHeader', key, val );

                });

            }

        });

    });

    /**

     * @fileOverview 没有图像处理的版本。

     */

    define('preset/withoutimage',[

        'base',

    
        // widgets

        'widgets/filednd',

        'widgets/filepaste',

        'widgets/filepicker',

        'widgets/queue',

        'widgets/runtime',

        'widgets/upload',

        'widgets/validator',

    
        // runtimes

        // html5

        'runtime/html5/blob',

        'runtime/html5/dnd',

        'runtime/html5/filepaste',

        'runtime/html5/filepicker',

        'runtime/html5/transport',

    
        // flash

        'runtime/flash/filepicker',

        'runtime/flash/transport'

    ], function( Base ) {

        return Base;

    });

    define('webuploader',[

        'preset/withoutimage'

    ], function( preset ) {

        return preset;

    });

    return require('webuploader');

});