yuanchengpeixun/demo/UEditor/third-party/webuploader/webuploader.withoutimage.js

/*! 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')
})