bce-bos-uploader-lite.js

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.baidubce = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file bce-bos-uploader/index.js
 * @author leeight
 */

var Q = require(44);
var BosClient = require(17);
var Auth = require(15);

var Uploader = require(31);
var utils = require(32);

module.exports = {
    bos: {
        Uploader: Uploader
    },
    utils: utils,
    sdk: {
        Q: Q,
        BosClient: BosClient,
        Auth: Auth
    }
};










},{"15":15,"17":17,"31":31,"32":32,"44":44}],2:[function(require,module,exports){
'use strict';
var mapAsync = require(9);
var doParallelLimit = require(3);
module.exports = doParallelLimit(mapAsync);



},{"3":3,"9":9}],3:[function(require,module,exports){
'use strict';

var eachOfLimit = require(4);

module.exports = function doParallelLimit(fn) {
    return function(obj, limit, iterator, cb) {
        return fn(eachOfLimit(limit), obj, iterator, cb);
    };
};

},{"4":4}],4:[function(require,module,exports){
var once = require(11);
var noop = require(10);
var onlyOnce = require(12);
var keyIterator = require(7);

module.exports = function eachOfLimit(limit) {
    return function(obj, iterator, cb) {
        cb = once(cb || noop);
        obj = obj || [];
        var nextKey = keyIterator(obj);
        if (limit <= 0) {
            return cb(null);
        }
        var done = false;
        var running = 0;
        var errored = false;

        (function replenish() {
            if (done && running <= 0) {
                return cb(null);
            }

            while (running < limit && !errored) {
                var key = nextKey();
                if (key === null) {
                    done = true;
                    if (running <= 0) {
                        cb(null);
                    }
                    return;
                }
                running += 1;
                iterator(obj[key], key, onlyOnce(function(err) {
                    running -= 1;
                    if (err) {
                        cb(err);
                        errored = true;
                    } else {
                        replenish();
                    }
                }));
            }
        })();
    };
};

},{"10":10,"11":11,"12":12,"7":7}],5:[function(require,module,exports){
'use strict';

module.exports = Array.isArray || function isArray(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
};

},{}],6:[function(require,module,exports){
'use strict';

var isArray = require(5);

module.exports = function isArrayLike(arr) {
    return isArray(arr) || (
        // has a positive integer length property
        typeof arr.length === 'number' &&
        arr.length >= 0 &&
        arr.length % 1 === 0
    );
};

},{"5":5}],7:[function(require,module,exports){
'use strict';

var _keys = require(8);
var isArrayLike = require(6);

module.exports = function keyIterator(coll) {
    var i = -1;
    var len;
    var keys;
    if (isArrayLike(coll)) {
        len = coll.length;
        return function next() {
            i++;
            return i < len ? i : null;
        };
    } else {
        keys = _keys(coll);
        len = keys.length;
        return function next() {
            i++;
            return i < len ? keys[i] : null;
        };
    }
};

},{"6":6,"8":8}],8:[function(require,module,exports){
'use strict';

module.exports = Object.keys || function keys(obj) {
    var _keys = [];
    for (var k in obj) {
        if (obj.hasOwnProperty(k)) {
            _keys.push(k);
        }
    }
    return _keys;
};

},{}],9:[function(require,module,exports){
'use strict';

var once = require(11);
var noop = require(10);
var isArrayLike = require(6);

module.exports = function mapAsync(eachfn, arr, iterator, cb) {
    cb = once(cb || noop);
    arr = arr || [];
    var results = isArrayLike(arr) ? [] : {};
    eachfn(arr, function (value, index, cb) {
        iterator(value, function (err, v) {
            results[index] = v;
            cb(err);
        });
    }, function (err) {
        cb(err, results);
    });
};

},{"10":10,"11":11,"6":6}],10:[function(require,module,exports){
'use strict';

module.exports = function noop () {};

},{}],11:[function(require,module,exports){
'use strict';

module.exports = function once(fn) {
    return function() {
        if (fn === null) return;
        fn.apply(this, arguments);
        fn = null;
    };
};

},{}],12:[function(require,module,exports){
'use strict';

module.exports = function only_once(fn) {
    return function() {
        if (fn === null) throw new Error('Callback was already called.');
        fn.apply(this, arguments);
        fn = null;
    };
};

},{}],13:[function(require,module,exports){
/**
 * lodash 3.0.3 (Custom Build) <https://lodash.com/>
 * Build: `lodash modularize exports="npm" -o ./`
 * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 * Available under MIT license <https://lodash.com/license>
 */

/** `Object#toString` result references. */
var numberTag = '[object Number]';

/** Used for built-in method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objectToString = objectProto.toString;

/**
 * Checks if `value` is object-like. A value is object-like if it's not `null`
 * and has a `typeof` result of "object".
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 * @example
 *
 * _.isObjectLike({});
 * // => true
 *
 * _.isObjectLike([1, 2, 3]);
 * // => true
 *
 * _.isObjectLike(_.noop);
 * // => false
 *
 * _.isObjectLike(null);
 * // => false
 */
function isObjectLike(value) {
  return !!value && typeof value == 'object';
}

/**
 * Checks if `value` is classified as a `Number` primitive or object.
 *
 * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified
 * as numbers, use the `_.isFinite` method.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isNumber(3);
 * // => true
 *
 * _.isNumber(Number.MIN_VALUE);
 * // => true
 *
 * _.isNumber(Infinity);
 * // => true
 *
 * _.isNumber('3');
 * // => false
 */
function isNumber(value) {
  return typeof value == 'number' ||
    (isObjectLike(value) && objectToString.call(value) == numberTag);
}

module.exports = isNumber;

},{}],14:[function(require,module,exports){
/**
 * lodash 3.0.2 (Custom Build) <https://lodash.com/>
 * Build: `lodash modern modularize exports="npm" -o ./`
 * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 * Available under MIT license <https://lodash.com/license>
 */

/**
 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(1);
 * // => false
 */
function isObject(value) {
  // Avoid a V8 JIT bug in Chrome 19-20.
  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
  var type = typeof value;
  return !!value && (type == 'object' || type == 'function');
}

module.exports = isObject;

},{}],15:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file src/auth.js
 * @author leeight
 */

/* eslint-env node */
/* eslint max-params:[0,10] */

var helper = require(42);
var util = require(47);
var u = require(46);
var H = require(19);
var strings = require(22);

/**
 * Auth
 *
 * @constructor
 * @param {string} ak The access key.
 * @param {string} sk The security key.
 */
function Auth(ak, sk) {
    this.ak = ak;
    this.sk = sk;
}

/**
 * Generate the signature based on http://gollum.baidu.com/AuthenticationMechanism
 *
 * @param {string} method The http request method, such as GET, POST, DELETE, PUT, ...
 * @param {string} resource The request path.
 * @param {Object=} params The query strings.
 * @param {Object=} headers The http request headers.
 * @param {number=} timestamp Set the current timestamp.
 * @param {number=} expirationInSeconds The signature validation time.
 * @param {Array.<string>=} headersToSign The request headers list which will be used to calcualate the signature.
 *
 * @return {string} The signature.
 */
Auth.prototype.generateAuthorization = function (method, resource, params,
                                                 headers, timestamp, expirationInSeconds, headersToSign) {

    var now = timestamp ? new Date(timestamp * 1000) : new Date();
    var rawSessionKey = util.format('bce-auth-v1/%s/%s/%d',
        this.ak, helper.toUTCString(now), expirationInSeconds || 1800);
    var sessionKey = this.hash(rawSessionKey, this.sk);

    var canonicalUri = this.uriCanonicalization(resource);
    var canonicalQueryString = this.queryStringCanonicalization(params || {});

    var rv = this.headersCanonicalization(headers || {}, headersToSign);
    var canonicalHeaders = rv[0];
    var signedHeaders = rv[1];

    var rawSignature = util.format('%s\n%s\n%s\n%s',
        method, canonicalUri, canonicalQueryString, canonicalHeaders);
    var signature = this.hash(rawSignature, sessionKey);

    if (signedHeaders.length) {
        return util.format('%s/%s/%s', rawSessionKey, signedHeaders.join(';'), signature);
    }

    return util.format('%s//%s', rawSessionKey, signature);
};

Auth.prototype.uriCanonicalization = function (uri) {
    return uri;
};

/**
 * Canonical the query strings.
 *
 * @see http://gollum.baidu.com/AuthenticationMechanism#生成CanonicalQueryString
 * @param {Object} params The query strings.
 * @return {string}
 */
Auth.prototype.queryStringCanonicalization = function (params) {
    var canonicalQueryString = [];
    u.each(u.keys(params), function (key) {
        if (key.toLowerCase() === H.AUTHORIZATION.toLowerCase()) {
            return;
        }

        var value = params[key] == null ? '' : params[key];
        canonicalQueryString.push(key + '=' + strings.normalize(value));
    });

    canonicalQueryString.sort();

    return canonicalQueryString.join('&');
};

/**
 * Canonical the http request headers.
 *
 * @see http://gollum.baidu.com/AuthenticationMechanism#生成CanonicalHeaders
 * @param {Object} headers The http request headers.
 * @param {Array.<string>=} headersToSign The request headers list which will be used to calcualate the signature.
 * @return {*} canonicalHeaders and signedHeaders
 */
Auth.prototype.headersCanonicalization = function (headers, headersToSign) {
    if (!headersToSign || !headersToSign.length) {
        headersToSign = [H.HOST, H.CONTENT_MD5, H.CONTENT_LENGTH, H.CONTENT_TYPE];
    }

    var headersMap = {};
    u.each(headersToSign, function (item) {
        headersMap[item.toLowerCase()] = true;
    });

    var canonicalHeaders = [];
    u.each(u.keys(headers), function (key) {
        var value = headers[key];
        value = u.isString(value) ? strings.trim(value) : value;
        if (value == null || value === '') {
            return;
        }
        key = key.toLowerCase();
        if (/^x\-bce\-/.test(key) || headersMap[key] === true) {
            canonicalHeaders.push(util.format('%s:%s',
                // encodeURIComponent(key), encodeURIComponent(value)));
                strings.normalize(key), strings.normalize(value)));
        }
    });

    canonicalHeaders.sort();

    var signedHeaders = [];
    u.each(canonicalHeaders, function (item) {
        signedHeaders.push(item.split(':')[0]);
    });

    return [canonicalHeaders.join('\n'), signedHeaders];
};

Auth.prototype.hash = function (data, key) {
    var crypto = require(40);
    var sha256Hmac = crypto.createHmac('sha256', key);
    sha256Hmac.update(data);
    return sha256Hmac.digest('hex');
};

module.exports = Auth;


},{"19":19,"22":22,"40":40,"42":42,"46":46,"47":47}],16:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file src/bce_base_client.js
 * @author leeight
 */

/* eslint-env node */

var EventEmitter = require(41).EventEmitter;
var util = require(47);
var Q = require(44);
var u = require(46);
var config = require(18);
var Auth = require(15);

/**
 * BceBaseClient
 *
 * @constructor
 * @param {Object} clientConfig The bce client configuration.
 * @param {string} serviceId The service id.
 * @param {boolean=} regionSupported The service supported region or not.
 */
function BceBaseClient(clientConfig, serviceId, regionSupported) {
    EventEmitter.call(this);

    this.config = u.extend({}, config.DEFAULT_CONFIG, clientConfig);
    this.serviceId = serviceId;
    this.regionSupported = !!regionSupported;

    this.config.endpoint = this._computeEndpoint();

    /**
     * @type {HttpClient}
     */
    this._httpAgent = null;
}
util.inherits(BceBaseClient, EventEmitter);

BceBaseClient.prototype._computeEndpoint = function () {
    if (this.config.endpoint) {
        return this.config.endpoint;
    }

    if (this.regionSupported) {
        return util.format('%s://%s.%s.%s',
            this.config.protocol,
            this.serviceId,
            this.config.region,
            config.DEFAULT_SERVICE_DOMAIN);
    }
    return util.format('%s://%s.%s',
        this.config.protocol,
        this.serviceId,
        config.DEFAULT_SERVICE_DOMAIN);
};

BceBaseClient.prototype.createSignature = function (credentials, httpMethod, path, params, headers) {
    return Q.fcall(function () {
        var auth = new Auth(credentials.ak, credentials.sk);
        return auth.generateAuthorization(httpMethod, path, params, headers);
    });
};

module.exports = BceBaseClient;


},{"15":15,"18":18,"41":41,"44":44,"46":46,"47":47}],17:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file src/bos_client.js
 * @author leeight
 */

/* eslint-env node */
/* eslint max-params:[0,10] */

var path = require(43);
var util = require(47);
var u = require(46);
var Buffer = require(33);
var H = require(19);
var strings = require(22);
var HttpClient = require(20);
var BceBaseClient = require(16);
var MimeType = require(21);

var MAX_PUT_OBJECT_LENGTH = 5368709120;     // 5G
var MAX_USER_METADATA_SIZE = 2048;          // 2 * 1024

/**
 * BOS service api
 *
 * @see http://gollum.baidu.com/BOS_API#BOS-API文档
 *
 * @constructor
 * @param {Object} config The bos client configuration.
 * @extends {BceBaseClient}
 */
function BosClient(config) {
    BceBaseClient.call(this, config, 'bos', true);

    /**
     * @type {HttpClient}
     */
    this._httpAgent = null;
}
util.inherits(BosClient, BceBaseClient);

// --- B E G I N ---
BosClient.prototype.deleteObject = function (bucketName, key, options) {
    options = options || {};

    return this.sendRequest('DELETE', {
        bucketName: bucketName,
        key: key,
        config: options.config
    });
};

BosClient.prototype.putObject = function (bucketName, key, data, options) {
    if (!key) {
        throw new TypeError('key should not be empty.');
    }

    options = this._checkOptions(options || {});

    return this.sendRequest('PUT', {
        bucketName: bucketName,
        key: key,
        body: data,
        headers: options.headers,
        config: options.config
    });
};

BosClient.prototype.putObjectFromBlob = function (bucketName, key, blob, options) {
    var headers = {};

    // https://developer.mozilla.org/en-US/docs/Web/API/Blob/size
    headers[H.CONTENT_LENGTH] = blob.size;
    // 对于浏览器调用API的时候，默认不添加 H.CONTENT_MD5 字段，因为计算起来比较慢
    // 而且根据 API 文档，这个字段不是必填的。
    options = u.extend(headers, options);

    return this.putObject(bucketName, key, blob, options);
};

BosClient.prototype.getObjectMetadata = function (bucketName, key, options) {
    options = options || {};

    return this.sendRequest('HEAD', {
        bucketName: bucketName,
        key: key,
        config: options.config
    });
};

BosClient.prototype.initiateMultipartUpload = function (bucketName, key, options) {
    options = options || {};

    var headers = {};
    headers[H.CONTENT_TYPE] = options[H.CONTENT_TYPE] || MimeType.guess(path.extname(key));
    return this.sendRequest('POST', {
        bucketName: bucketName,
        key: key,
        params: {uploads: ''},
        headers: headers,
        config: options.config
    });
};

BosClient.prototype.abortMultipartUpload = function (bucketName, key, uploadId, options) {
    options = options || {};

    return this.sendRequest('DELETE', {
        bucketName: bucketName,
        key: key,
        params: {uploadId: uploadId},
        config: options.config
    });
};

BosClient.prototype.completeMultipartUpload = function (bucketName, key, uploadId, partList, options) {
    var headers = {};
    headers[H.CONTENT_TYPE] = 'application/json; charset=UTF-8';
    options = this._checkOptions(u.extend(headers, options));

    return this.sendRequest('POST', {
        bucketName: bucketName,
        key: key,
        body: JSON.stringify({parts: partList}),
        headers: options.headers,
        params: {uploadId: uploadId},
        config: options.config
    });
};

BosClient.prototype.uploadPartFromBlob = function (bucketName, key, uploadId, partNumber,
                                                   partSize, blob, options) {
    if (blob.size !== partSize) {
        throw new TypeError(util.format('Invalid partSize %d and data length %d',
            partSize, blob.size));
    }

    var headers = {};
    headers[H.CONTENT_LENGTH] = partSize;
    headers[H.CONTENT_TYPE] = 'application/octet-stream';

    options = this._checkOptions(u.extend(headers, options));
    return this.sendRequest('PUT', {
        bucketName: bucketName,
        key: key,
        body: blob,
        headers: options.headers,
        params: {
            partNumber: partNumber,
            uploadId: uploadId
        },
        config: options.config
    });
};

BosClient.prototype.listParts = function (bucketName, key, uploadId, options) {
    /*eslint-disable*/
    if (!uploadId) {
        throw new TypeError('uploadId should not empty');
    }
    /*eslint-enable*/

    var allowedParams = ['maxParts', 'partNumberMarker', 'uploadId'];
    options = this._checkOptions(options || {}, allowedParams);
    options.params.uploadId = uploadId;

    return this.sendRequest('GET', {
        bucketName: bucketName,
        key: key,
        params: options.params,
        config: options.config
    });
};

BosClient.prototype.listMultipartUploads = function (bucketName, options) {
    var allowedParams = ['delimiter', 'maxUploads', 'keyMarker', 'prefix', 'uploads'];

    options = this._checkOptions(options || {}, allowedParams);
    options.params.uploads = '';

    return this.sendRequest('GET', {
        bucketName: bucketName,
        params: options.params,
        config: options.config
    });
};

BosClient.prototype.appendObject = function (bucketName, key, data, offset, options) {
    if (!key) {
        throw new TypeError('key should not be empty.');
    }

    options = this._checkOptions(options || {});
    var params = {append: ''};
    if (u.isNumber(offset)) {
        params.offset = offset;
    }
    return this.sendRequest('POST', {
        bucketName: bucketName,
        key: key,
        body: data,
        headers: options.headers,
        params: params,
        config: options.config
    });
};

BosClient.prototype.appendObjectFromBlob = function (bucketName, key, blob, offset, options) {
    var headers = {};

    // https://developer.mozilla.org/en-US/docs/Web/API/Blob/size
    headers[H.CONTENT_LENGTH] = blob.size;
    // 对于浏览器调用API的时候，默认不添加 H.CONTENT_MD5 字段，因为计算起来比较慢
    // 而且根据 API 文档，这个字段不是必填的。
    options = u.extend(headers, options);

    return this.appendObject(bucketName, key, blob, offset, options);
};

// --- E N D ---

BosClient.prototype.sendRequest = function (httpMethod, varArgs) {
    var defaultArgs = {
        bucketName: null,
        key: null,
        body: null,
        headers: {},
        params: {},
        config: {},
        outputStream: null
    };
    var args = u.extend(defaultArgs, varArgs);

    var config = u.extend({}, this.config, args.config);
    var resource = [
        '/v1',
        strings.normalize(args.bucketName || ''),
        strings.normalize(args.key || '', false)
    ].join('/');

    if (config.sessionToken) {
        args.headers[H.SESSION_TOKEN] = config.sessionToken;
    }

    return this.sendHTTPRequest(httpMethod, resource, args, config);
};

BosClient.prototype.sendHTTPRequest = function (httpMethod, resource, args, config) {
    var client = this;
    var agent = this._httpAgent = new HttpClient(config);

    var httpContext = {
        httpMethod: httpMethod,
        resource: resource,
        args: args,
        config: config
    };
    u.each(['progress', 'error', 'abort'], function (eventName) {
        agent.on(eventName, function (evt) {
            client.emit(eventName, evt, httpContext);
        });
    });

    var promise = this._httpAgent.sendRequest(httpMethod, resource, args.body,
        args.headers, args.params, u.bind(this.createSignature, this),
        args.outputStream
    );

    promise.abort = function () {
        if (agent._req && agent._req.xhr) {
            var xhr = agent._req.xhr;
            xhr.abort();
        }
    };

    return promise;
};

BosClient.prototype._checkOptions = function (options, allowedParams) {
    var rv = {};

    rv.config = options.config || {};
    rv.headers = this._prepareObjectHeaders(options);
    rv.params = u.pick(options, allowedParams || []);

    return rv;
};

BosClient.prototype._prepareObjectHeaders = function (options) {
    var allowedHeaders = {};
    u.each([
        H.CONTENT_LENGTH,
        H.CONTENT_ENCODING,
        H.CONTENT_MD5,
        H.X_BCE_CONTENT_SHA256,
        H.CONTENT_TYPE,
        H.CONTENT_DISPOSITION,
        H.ETAG,
        H.SESSION_TOKEN,
        H.CACHE_CONTROL,
        H.EXPIRES,
        H.X_BCE_OBJECT_ACL,
        H.X_BCE_OBJECT_GRANT_READ
    ], function (header) {
        allowedHeaders[header] = true;
    });

    var metaSize = 0;
    var headers = u.pick(options, function (value, key) {
        if (allowedHeaders[key]) {
            return true;
        }
        else if (/^x\-bce\-meta\-/.test(key)) {
            metaSize += Buffer.byteLength(key) + Buffer.byteLength('' + value);
            return true;
        }
    });

    if (metaSize > MAX_USER_METADATA_SIZE) {
        throw new TypeError('Metadata size should not be greater than ' + MAX_USER_METADATA_SIZE + '.');
    }

    if (headers.hasOwnProperty(H.CONTENT_LENGTH)) {
        var contentLength = headers[H.CONTENT_LENGTH];
        if (contentLength < 0) {
            throw new TypeError('content_length should not be negative.');
        }
        else if (contentLength > MAX_PUT_OBJECT_LENGTH) { // 5G
            throw new TypeError('Object length should be less than ' + MAX_PUT_OBJECT_LENGTH
                + '. Use multi-part upload instead.');
        }
    }

    if (headers.hasOwnProperty('ETag')) {
        var etag = headers.ETag;
        if (!/^"/.test(etag)) {
            headers.ETag = util.format('"%s"', etag);
        }
    }

    if (!headers.hasOwnProperty(H.CONTENT_TYPE)) {
        headers[H.CONTENT_TYPE] = 'application/octet-stream';
    }

    return headers;
};

module.exports = BosClient;

},{"16":16,"19":19,"20":20,"21":21,"22":22,"33":33,"43":43,"46":46,"47":47}],18:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file src/config.js
 * @author leeight
 */

/* eslint-env node */

exports.DEFAULT_SERVICE_DOMAIN = 'baidubce.com';

exports.DEFAULT_CONFIG = {
    protocol: 'http',
    region: 'bj'
};











},{}],19:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file src/headers.js
 * @author leeight
 */

/* eslint-env node */

exports.CONTENT_TYPE = 'Content-Type';
exports.CONTENT_LENGTH = 'Content-Length';
exports.CONTENT_MD5 = 'Content-MD5';
exports.CONTENT_ENCODING = 'Content-Encoding';
exports.CONTENT_DISPOSITION = 'Content-Disposition';
exports.ETAG = 'ETag';
exports.CONNECTION = 'Connection';
exports.HOST = 'Host';
exports.USER_AGENT = 'User-Agent';
exports.CACHE_CONTROL = 'Cache-Control';
exports.EXPIRES = 'Expires';

exports.AUTHORIZATION = 'Authorization';
exports.X_BCE_DATE = 'x-bce-date';
exports.X_BCE_ACL = 'x-bce-acl';
exports.X_BCE_REQUEST_ID = 'x-bce-request-id';
exports.X_BCE_CONTENT_SHA256 = 'x-bce-content-sha256';
exports.X_BCE_OBJECT_ACL = 'x-bce-object-acl';
exports.X_BCE_OBJECT_GRANT_READ = 'x-bce-object-grant-read';

exports.X_HTTP_HEADERS = 'http_headers';
exports.X_BODY = 'body';
exports.X_STATUS_CODE = 'status_code';
exports.X_MESSAGE = 'message';
exports.X_CODE = 'code';
exports.X_REQUEST_ID = 'request_id';

exports.SESSION_TOKEN = 'x-bce-security-token';

exports.X_VOD_MEDIA_TITLE = 'x-vod-media-title';
exports.X_VOD_MEDIA_DESCRIPTION = 'x-vod-media-description';
exports.ACCEPT_ENCODING = 'accept-encoding';
exports.ACCEPT = 'accept';












},{}],20:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file src/http_client.js
 * @author leeight
 */

/* eslint-env node */
/* eslint max-params:[0,10] */
/* globals ArrayBuffer */

var EventEmitter = require(41).EventEmitter;
var Buffer = require(33);
var Q = require(44);
var helper = require(42);
var u = require(46);
var util = require(47);
var H = require(19);

/**
 * The HttpClient
 *
 * @constructor
 * @param {Object} config The http client configuration.
 */
function HttpClient(config) {
    EventEmitter.call(this);

    this.config = config;

    /**
     * http(s) request object
     * @type {Object}
     */
    this._req = null;
}
util.inherits(HttpClient, EventEmitter);

/**
 * Send Http Request
 *
 * @param {string} httpMethod GET,POST,PUT,DELETE,HEAD
 * @param {string} path The http request path.
 * @param {(string|Buffer|stream.Readable)=} body The request body. If `body` is a
 * stream, `Content-Length` must be set explicitly.
 * @param {Object=} headers The http request headers.
 * @param {Object=} params The querystrings in url.
 * @param {function():string=} signFunction The `Authorization` signature function
 * @param {stream.Writable=} outputStream The http response body.
 * @param {number=} retry The maximum number of network connection attempts.
 *
 * @resolve {{http_headers:Object,body:Object}}
 * @reject {Object}
 *
 * @return {Q.defer}
 */
HttpClient.prototype.sendRequest = function (httpMethod, path, body, headers, params,
                                             signFunction, outputStream) {

    var requestUrl = this._getRequestUrl(path, params);

    var defaultHeaders = {};
    defaultHeaders[H.X_BCE_DATE] = helper.toUTCString(new Date());
    defaultHeaders[H.CONTENT_TYPE] = 'application/json; charset=UTF-8';
    defaultHeaders[H.HOST] = /^\w+:\/\/([^\/]+)/.exec(this.config.endpoint)[1];

    var requestHeaders = u.extend(defaultHeaders, headers);

    // Check the content-length
    if (!requestHeaders.hasOwnProperty(H.CONTENT_LENGTH)) {
        var contentLength = this._guessContentLength(body);
        if (!(contentLength === 0 && /GET|HEAD/i.test(httpMethod))) {
            // 如果是 GET 或 HEAD 请求，并且 Content-Length 是 0，那么 Request Header 里面就不要出现 Content-Length
            // 否则本地计算签名的时候会计算进去，但是浏览器发请求的时候不一定会有，此时导致 Signature Mismatch 的情况
            requestHeaders[H.CONTENT_LENGTH] = contentLength;
        }
    }

    var self = this;
    var createSignature = signFunction || u.noop;
    try {
        return Q.resolve(createSignature(this.config.credentials, httpMethod, path, params, requestHeaders))
            .then(function (authorization, xbceDate) {
                if (authorization) {
                    requestHeaders[H.AUTHORIZATION] = authorization;
                }

                if (xbceDate) {
                    requestHeaders[H.X_BCE_DATE] = xbceDate;
                }

                return self._doRequest(httpMethod, requestUrl,
                    u.omit(requestHeaders, H.CONTENT_LENGTH, H.HOST),
                    body, outputStream);
            });
    }
    catch (ex) {
        return Q.reject(ex);
    }
};

HttpClient.prototype._doRequest = function (httpMethod, requestUrl, requestHeaders, body, outputStream) {
    var deferred = Q.defer();

    var self = this;
    var xhr = new XMLHttpRequest();
    xhr.open(httpMethod, requestUrl, true);
    for (var header in requestHeaders) {
        if (requestHeaders.hasOwnProperty(header)) {
            var value = requestHeaders[header];
            xhr.setRequestHeader(header, value);
        }
    }
    xhr.onerror = function (error) {
        deferred.reject(error);
    };
    xhr.onabort = function () {
        deferred.reject(new Error('xhr aborted'));
    };
    xhr.onreadystatechange = function () {
        if (xhr.readyState === 4) {
            var status = xhr.status;
            if (status === 1223) {
                // IE - #1450: sometimes returns 1223 when it should be 204
                status = 204;
            }

            var contentType = xhr.getResponseHeader('Content-Type');
            var isJSON = /application\/json/.test(contentType);
            var responseBody = isJSON ? JSON.parse(xhr.responseText) : xhr.responseText;
            if (!responseBody) {
                responseBody = {
                    location: requestUrl
                };
            }

            var isSuccess = status >= 200 && status < 300 || status === 304;
            if (isSuccess) {
                var headers = self._fixHeaders(xhr.getAllResponseHeaders());
                deferred.resolve({
                    http_headers: headers,
                    body: responseBody
                });
            }
            else {
                deferred.reject({
                    status_code: status,
                    message: responseBody.message || '<message>',
                    code: responseBody.code || '<code>',
                    request_id: responseBody.requestId || '<request_id>'
                });
            }
        }
    };
    if (xhr.upload) {
        u.each(['progress', 'error', 'abort'], function (eventName) {
            xhr.upload.addEventListener(eventName, function (evt) {
                if (typeof self.emit === 'function') {
                    self.emit(eventName, evt);
                }
            }, false);
        });
    }
    xhr.send(body);

    self._req = {xhr: xhr};

    return deferred.promise;
};

HttpClient.prototype._guessContentLength = function (data) {
    if (data == null || data === '') {
        return 0;
    }
    else if (u.isString(data)) {
        return Buffer.byteLength(data);
    }
    else if (typeof Blob !== 'undefined' && data instanceof Blob) {
        return data.size;
    }
    else if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer) {
        return data.byteLength;
    }

    throw new Error('No Content-Length is specified.');
};

HttpClient.prototype._fixHeaders = function (headers) {
    var fixedHeaders = {};

    if (headers) {
        u.each(headers.split(/\r?\n/), function (line) {
            var idx = line.indexOf(':');
            if (idx !== -1) {
                var key = line.substring(0, idx).toLowerCase();
                var value = line.substring(idx + 1).replace(/^\s+|\s+$/, '');
                if (key === 'etag') {
                    value = value.replace(/"/g, '');
                }
                fixedHeaders[key] = value;
            }
        });
    }

    return fixedHeaders;
};

HttpClient.prototype.buildQueryString = function (params) {
    var urlEncodeStr = require(45).stringify(params);
    // https://en.wikipedia.org/wiki/Percent-encoding
    return urlEncodeStr.replace(/[()'!~.*\-_]/g, function (char) {
        return '%' + char.charCodeAt().toString(16);
    });
};

HttpClient.prototype._getRequestUrl = function (path, params) {
    var uri = path;
    var qs = this.buildQueryString(params);
    if (qs) {
        uri += '?' + qs;
    }

    return this.config.endpoint + uri;
};

module.exports = HttpClient;


},{"19":19,"33":33,"41":41,"42":42,"44":44,"45":45,"46":46,"47":47}],21:[function(require,module,exports){
/**
 * @file src/mime.types.js
 * @author leeight
 */

/* eslint-env node */

var mimeTypes = {
};

exports.guess = function (ext) {
    if (!ext || !ext.length) {
        return 'application/octet-stream';
    }
    if (ext[0] === '.') {
        ext = ext.substr(1);
    }
    return mimeTypes[ext.toLowerCase()] || 'application/octet-stream';
};

},{}],22:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file strings.js
 * @author leeight
 */

var kEscapedMap = {
    '!': '%21',
    '\'': '%27',
    '(': '%28',
    ')': '%29',
    '*': '%2A'
};

exports.normalize = function (string, encodingSlash) {
    var result = encodeURIComponent(string);
    result = result.replace(/[!'\(\)\*]/g, function ($1) {
        return kEscapedMap[$1];
    });

    if (encodingSlash === false) {
        result = result.replace(/%2F/gi, '/');
    }

    return result;
};

exports.trim = function (string) {
    return (string || '').replace(/^\s+|\s+$/g, '');
};


},{}],23:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file config.js
 * @author leeight
 */


var kDefaultOptions = {
    runtimes: 'html5',

    // bos服务器的地址，默认(http://bj.bcebos.com)
    // 这里不应该是 https://bj.bcebos.com，否则 Moxie.swf 可能有问题，原因未知
    bos_endpoint: 'http://bj.bcebos.com',

    // 默认的 ak 和 sk 配置
    bos_ak: null,
    bos_sk: null,
    bos_credentials: null,

    // 如果切换到 appendable 模式，最大只支持 5G 的文件
    // 不再支持 Multipart 的方式上传文件
    bos_appendable: false,

    // 为了处理 Flash 不能发送 HEAD, DELETE 之类的请求，以及无法
    // 获取 response headers 的问题，需要搞一个 relay 服务器，把数据
    // 格式转化一下
    bos_relay_server: 'https://relay.efe.tech',

    // 是否支持多选，默认(false)
    multi_selection: false,

    // 失败之后重试的次数(单个文件或者分片)，默认(0)，不重试
    max_retries: 0,

    // 失败重试的间隔时间，默认 1000ms
    retry_interval: 1000,

    // 是否自动上传，默认(false)
    auto_start: false,

    // 最大可以选择的文件大小，默认(100M)
    max_file_size: '100mb',

    // 超过这个文件大小之后，开始使用分片上传，默认(10M)
    bos_multipart_min_size: '10mb',

    // 分片上传的时候，并行上传的个数，默认(1)
    bos_multipart_parallel: 1,

    // 队列中的文件，并行上传的个数，默认(3)
    bos_task_parallel: 3,

    // 计算签名的时候，有些 header 需要剔除，减少传输的体积
    auth_stripped_headers: ['User-Agent', 'Connection'],

    // 分片上传的时候，每个分片的大小，默认(4M)
    chunk_size: '4mb',

    // 分块上传时,是否允许断点续传，默认(false)
    bos_multipart_auto_continue: false,

    // 分开上传的时候，localStorage里面key的生成方式，默认是 `default`
    // 如果需要自定义，可以通过 XXX
    bos_multipart_local_key_generator: 'default',

    // 是否允许选择目录
    dir_selection: false,

    // 是否需要每次都去服务器计算签名
    get_new_uptoken: true,

    // 因为使用 Form Post 的格式，没有设置额外的 Header，从而可以保证
    // 使用 Flash 也能上传大文件
    // 低版本浏览器上传文件的时候，需要设置 policy，默认情况下
    // policy的内容只需要包含 expiration 和 conditions 即可
    // policy: {
    //   expiration: 'xx',
    //   conditions: [
    //     {bucket: 'the-bucket-name'}
    //   ]
    // }
    // bos_policy: null,

    // 低版本浏览器上传文件的时候，需要设置 policy_signature
    // 如果没有设置 bos_policy_signature 的话，会通过 uptoken_url 来请求
    // 默认只会请求一次，如果失效了，需要手动来重置 policy_signature
    // bos_policy_signature: null,

    // JSONP 默认的超时时间(5000ms)
    uptoken_via_jsonp: true,
    uptoken_timeout: 5000,
    uptoken_jsonp_timeout: 5000,    // 不支持了，后续建议用 uptoken_timeout

    // 是否要禁用统计，默认不禁用
    // 如果需要禁用，把 tracker_id 设置成 null 即可
    tracker_id: null
};

module.exports = kDefaultOptions;











},{}],24:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"), you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file events.js
 * @author leeight
 */

module.exports = {
    kPostInit: 'PostInit',
    kKey: 'Key',
    kListParts: 'ListParts',
    kObjectMetas: 'ObjectMetas',
    // kFilesRemoved  : 'FilesRemoved',
    kFileFiltered: 'FileFiltered',
    kFilesAdded: 'FilesAdded',
    kFilesFilter: 'FilesFilter',
    kNetworkSpeed: 'NetworkSpeed',
    kBeforeUpload: 'BeforeUpload',
    // kUploadFile    : 'UploadFile',       // ??
    kUploadProgress: 'UploadProgress',
    kFileUploaded: 'FileUploaded',
    kUploadPartProgress: 'UploadPartProgress',
    kChunkUploaded: 'ChunkUploaded',
    kUploadResume: 'UploadResume', // 断点续传
    // kUploadPause: 'UploadPause',   // 暂停
    kUploadResumeError: 'UploadResumeError', // 尝试断点续传失败
    kUploadComplete: 'UploadComplete',
    kError: 'Error',
    kAborted: 'Aborted'
};

},{}],25:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file multipart_task.js
 * @author leeight
 */

var Q = require(44);
var async = require(35);
var u = require(46);
var utils = require(32);
var events = require(24);
var Task = require(30);

/**
 * MultipartTask
 *
 * @class
 */
function MultipartTask() {
    Task.apply(this, arguments);

    /**
     * 批量上传的时候，保存的 xhrRequesting 对象
     * 如果需要 abort 的时候，从这里来获取
     */
    this.xhrPools = [];
}
utils.inherits(MultipartTask, Task);

MultipartTask.prototype.start = function () {
    if (this.aborted) {
        return Q.resolve();
    }

    var self = this;

    var dispatcher = this.eventDispatcher;

    var file = this.options.file;
    var bucket = this.options.bucket;
    var object = this.options.object;
    var metas = this.options.metas;
    var chunkSize = this.options.chunk_size;
    var multipartParallel = this.options.bos_multipart_parallel;

    var contentType = utils.guessContentType(file);
    var options = {'Content-Type': contentType};
    var uploadId = null;

    return this._initiateMultipartUpload(file, chunkSize, bucket, object, options)
        .then(function (response) {
            uploadId = response.body.uploadId;
            var parts = response.body.parts || [];
            // 准备 uploadParts
            var deferred = Q.defer();
            var tasks = utils.getTasks(file, uploadId, chunkSize, bucket, object);
            utils.filterTasks(tasks, parts);

            var loaded = parts.length;
            // 这个用来记录整体 Parts 的上传进度，不是单个 Part 的上传进度
            // 单个 Part 的上传进度可以监听 kUploadPartProgress 来得到
            var state = {
                lengthComputable: true,
                loaded: loaded,
                total: tasks.length
            };
            file._previousLoaded = loaded * chunkSize;
            if (loaded) {
                var progress = file._previousLoaded / file.size;
                dispatcher.dispatchEvent(events.kUploadProgress, [file, progress, null]);
            }

            async.mapLimit(tasks, multipartParallel, self._uploadPart(state),
                function (err, results) {
                    if (err) {
                        deferred.reject(err);
                    }
                    else {
                        deferred.resolve(results);
                    }
                });

            return deferred.promise;
        })
        .then(function (responses) {
            var partList = [];
            u.each(responses, function (response, index) {
                partList.push({
                    partNumber: index + 1,
                    eTag: response.http_headers.etag
                });
            });
            // 全部上传结束后删除localStorage
            self._generateLocalKey({
                blob: file,
                chunkSize: chunkSize,
                bucket: bucket,
                object: object
            }).then(function (key) {
                utils.removeUploadId(key);
            });
            return self.client.completeMultipartUpload(bucket, object, uploadId, partList, metas);
        })
        .then(function (response) {
            dispatcher.dispatchEvent(events.kUploadProgress, [file, 1]);

            response.body.bucket = bucket;
            response.body.object = object;

            dispatcher.dispatchEvent(events.kFileUploaded, [file, response]);
        })[
        "catch"](function (error) {
            var eventType = self.aborted ? events.kAborted : events.kError;
            dispatcher.dispatchEvent(eventType, [error, file]);
        });
};


MultipartTask.prototype._initiateMultipartUpload = function (file, chunkSize, bucket, object, options) {
    var self = this;
    var dispatcher = this.eventDispatcher;

    var uploadId;
    var localSaveKey;

    function initNewMultipartUpload() {
        return self.client.initiateMultipartUpload(bucket, object, options)
            .then(function (response) {
                if (localSaveKey) {
                    utils.setUploadId(localSaveKey, response.body.uploadId);
                }

                response.body.parts = [];
                return response;
            });
    }

    var keyOptions = {
        blob: file,
        chunkSize: chunkSize,
        bucket: bucket,
        object: object
    };
    var promise = this.options.bos_multipart_auto_continue
        ? this._generateLocalKey(keyOptions)
        : Q.resolve(null);

    return promise.then(function (key) {
            localSaveKey = key;
            if (!localSaveKey) {
                return initNewMultipartUpload();
            }

            uploadId = utils.getUploadId(localSaveKey);
            if (!uploadId) {
                return initNewMultipartUpload();
            }

            return self._listParts(file, bucket, object, uploadId);
        })
        .then(function (response) {
            if (uploadId && localSaveKey) {
                var parts = response.body.parts;
                // listParts 的返回结果
                dispatcher.dispatchEvent(events.kUploadResume, [file, parts, null]);
                response.body.uploadId = uploadId;
            }
            return response;
        })[
        "catch"](function (error) {
            if (uploadId && localSaveKey) {
                // 如果获取已上传分片失败，则重新上传。
                dispatcher.dispatchEvent(events.kUploadResumeError, [file, error, null]);
                utils.removeUploadId(localSaveKey);
                return initNewMultipartUpload();
            }
            throw error;
        });
};

MultipartTask.prototype._generateLocalKey = function (options) {
    var generator = this.options.bos_multipart_local_key_generator;
    return utils.generateLocalKey(options, generator);
};

MultipartTask.prototype._listParts = function (file, bucket, object, uploadId) {
    var self = this;
    var dispatcher = this.eventDispatcher;

    var localParts = dispatcher.dispatchEvent(events.kListParts, [file, uploadId]);

    return Q.resolve(localParts)
        .then(function (parts) {
            if (u.isArray(parts) && parts.length) {
                return {
                    http_headers: {},
                    body: {
                        parts: parts
                    }
                };
            }

            // 如果返回的不是数组，就调用 listParts 接口从服务器获取数据
            return self._listAllParts(bucket, object, uploadId);
        });
};

MultipartTask.prototype._listAllParts = function (bucket, object, uploadId) {
    // isTruncated === true / false
    var self = this;
    var deferred = Q.defer();

    var parts = [];
    var payload = null;
    var maxParts = 1000;          // 每次的分页
    var partNumberMarker = 0;     // 分隔符

    function listParts() {
        var options = {
            maxParts: maxParts,
            partNumberMarker: partNumberMarker
        };
        self.client.listParts(bucket, object, uploadId, options)
            .then(function (response) {
                if (payload == null) {
                    payload = response;
                }

                parts.push.apply(parts, response.body.parts);
                partNumberMarker = response.body.nextPartNumberMarker;

                if (response.body.isTruncated === false) {
                    // 结束了
                    payload.body.parts = parts;
                    deferred.resolve(payload);
                }
                else {
                    // 递归调用
                    listParts();
                }
            })[
            "catch"](function (error) {
                deferred.reject(error);
            });
    }
    listParts();

    return deferred.promise;
};

MultipartTask.prototype._uploadPart = function (state) {
    var self = this;
    var dispatcher = this.eventDispatcher;

    function uploadPartInner(item, opt_maxRetries) {
        if (item.etag) {
            self.networkInfo.loadedBytes += item.partSize;

            // 跳过已上传的part
            return Q.resolve({
                http_headers: {
                    etag: item.etag
                },
                body: {}
            });
        }
        var maxRetries = opt_maxRetries == null
            ? self.options.max_retries
            : opt_maxRetries;
        var retryInterval = self.options.retry_interval;

        var blob = item.file.slice(item.start, item.stop + 1);
        blob._parentUUID = item.file.uuid;    // 后续根据分片来查找原始文件的时候，会用到
        blob._previousLoaded = 0;

        var uploadPartXhr = self.client.uploadPartFromBlob(item.bucket, item.object,
            item.uploadId, item.partNumber, item.partSize, blob);
        var xhrPoolIndex = self.xhrPools.push(uploadPartXhr);

        return uploadPartXhr.then(function (response) {
                ++state.loaded;
                // var progress = state.loaded / state.total;
                // dispatcher.dispatchEvent(events.kUploadProgress, [item.file, progress, null]);

                var result = {
                    uploadId: item.uploadId,
                    partNumber: item.partNumber,
                    partSize: item.partSize,
                    bucket: item.bucket,
                    object: item.object,
                    offset: item.start,
                    total: blob.size,
                    response: response
                };
                dispatcher.dispatchEvent(events.kChunkUploaded, [item.file, result]);

                // 不用删除，设置为 null 就好了，反正 abort 的时候会判断的
                self.xhrPools[xhrPoolIndex - 1] = null;

                return response;
            })[
            "catch"](function (error) {
                if (maxRetries > 0 && !self.aborted) {
                    // 还有重试的机会
                    return utils.delay(retryInterval).then(function () {
                        return uploadPartInner(item, maxRetries - 1);
                    });
                }
                // 没有机会重试了 :-(
                throw error;
            });

    }

    return function (item, callback) {
        // file: file,
        // uploadId: uploadId,
        // bucket: bucket,
        // object: object,
        // partNumber: partNumber,
        // partSize: partSize,
        // start: offset,
        // stop: offset + partSize - 1

        var resolve = function (response) {
            callback(null, response);
        };
        var reject = function (error) {
            callback(error);
        };

        uploadPartInner(item).then(resolve, reject);
    };
};

/**
 * 终止上传任务
 */
MultipartTask.prototype.abort = function () {
    this.aborted = true;
    this.xhrRequesting = null;
    for (var i = 0; i < this.xhrPools.length; i++) {
        var xhr = this.xhrPools[i];
        if (xhr && typeof xhr.abort === 'function') {
            xhr.abort();
        }
    }
};


module.exports = MultipartTask;

},{"24":24,"30":30,"32":32,"35":35,"44":44,"46":46}],26:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file src/network_info.js
 * @author leeight
 */

var utils = require(32);

/**
 * NetworkInfo
 *
 * @class
 */
function NetworkInfo() {
    /**
     * 记录从 start 开始已经上传的字节数.
     * @type {number}
     */
    this.loadedBytes = 0;

    /**
     * 记录队列中总文件的大小, UploadComplete 之后会被清零
     * @type {number}
     */
    this.totalBytes = 0;

    /**
     * 记录开始上传的时间.
     * @type {number}
     */
    this._startTime = utils.now();

    this.reset();
}

NetworkInfo.prototype.dump = function () {
    return [
        this.loadedBytes,                     // 已经上传的
        utils.now() - this._startTime,        // 花费的时间
        this.totalBytes - this.loadedBytes    // 剩余未上传的
    ];
};

NetworkInfo.prototype.reset = function () {
    this.loadedBytes = 0;
    this._startTime = utils.now();
};

module.exports = NetworkInfo;

},{"32":32}],27:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file put_object_task.js
 * @author leeight
 */

var Q = require(44);
var u = require(46);
var utils = require(32);
var events = require(24);
var Task = require(30);

/**
 * PutObjectTask
 *
 * @class
 */
function PutObjectTask() {
    Task.apply(this, arguments);
}
utils.inherits(PutObjectTask, Task);

PutObjectTask.prototype.start = function (opt_maxRetries) {
    if (this.aborted) {
        return Q.resolve();
    }

    var self = this;

    var dispatcher = this.eventDispatcher;

    var file = this.options.file;
    var bucket = this.options.bucket;
    var object = this.options.object;
    var metas = this.options.metas;
    var maxRetries = opt_maxRetries == null
        ? this.options.max_retries
        : opt_maxRetries;
    var retryInterval = this.options.retry_interval;

    var contentType = utils.guessContentType(file);
    var options = u.extend({'Content-Type': contentType}, metas);

    this.xhrRequesting = this.client.putObjectFromBlob(bucket, object, file, options);

    return this.xhrRequesting.then(function (response) {
        dispatcher.dispatchEvent(events.kUploadProgress, [file, 1]);

        response.body.bucket = bucket;
        response.body.key = object;

        dispatcher.dispatchEvent(events.kFileUploaded, [file, response]);
    })[
    "catch"](function (error) {
        var eventType = self.aborted ? events.kAborted : events.kError;
        dispatcher.dispatchEvent(eventType, [error, file]);

        if (error.status_code && error.code && error.request_id) {
            // 应该是正常的错误(比如签名异常)，这种情况就不要重试了
            return Q.resolve();
        }
        // else if (error.status_code === 0) {
        //    // 可能是断网了，safari 触发 online/offline 延迟比较久
        //    // 我们推迟一下 self._uploadNext() 的时机
        //    self.pause();
        //    return;
        // }
        else if (maxRetries > 0 && !self.aborted) {
            // 还有机会重试
            return utils.delay(retryInterval).then(function () {
                return self.start(maxRetries - 1);
            });
        }

        // 重试结束了，不管了，继续下一个文件的上传
        return Q.resolve();
    });
};


module.exports = PutObjectTask;

},{"24":24,"30":30,"32":32,"44":44,"46":46}],28:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file src/queue.js
 * @author leeight
 */

/**
 * Queue
 *
 * @class
 * @param {*} collection The collection.
 */
function Queue(collection) {
    this.collection = collection;
}

Queue.prototype.isEmpty = function () {
    return this.collection.length <= 0;
};

Queue.prototype.size = function () {
    return this.collection.length;
};

Queue.prototype.dequeue = function () {
    return this.collection.shift();
};

module.exports = Queue;











},{}],29:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file sts_token_manager.js
 * @author leeight
 */

var Q = require(44);
var utils = require(32);

/**
 * StsTokenManager
 *
 * @class
 * @param {Object} options The options.
 */
function StsTokenManager(options) {
    this.options = options;

    this._cache = {};
}

StsTokenManager.prototype.get = function (bucket) {
    var self = this;

    if (self._cache[bucket] != null) {
        return self._cache[bucket];
    }

    return Q.resolve(this._getImpl.apply(this, arguments)).then(function (payload) {
        self._cache[bucket] = payload;
        return payload;
    });
};

StsTokenManager.prototype._getImpl = function (bucket) {
    var options = this.options;
    var uptoken_url = options.uptoken_url;
    var timeout = options.uptoken_timeout || options.uptoken_jsonp_timeout;
    var viaJsonp = options.uptoken_via_jsonp;

    var deferred = Q.defer();
    $.ajax({
        url: uptoken_url,
        jsonp: viaJsonp ? 'callback' : false,
        dataType: viaJsonp ? 'jsonp' : 'json',
        timeout: timeout,
        data: {
            sts: JSON.stringify(utils.getDefaultACL(bucket))
        },
        success: function (payload) {
            // payload.AccessKeyId
            // payload.SecretAccessKey
            // payload.SessionToken
            // payload.Expiration
            deferred.resolve(payload);
        },
        error: function () {
            deferred.reject(new Error('Get sts token timeout (' + timeout + 'ms).'));
        }
    });

    return deferred.promise;
};

module.exports = StsTokenManager;

},{"32":32,"44":44}],30:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file task.js
 * @author leeight
 */


/**
 * 不同的场景下，需要通过不同的Task来完成上传的工作
 *
 * @param {sdk.BosClient} client The bos client.
 * @param {EventDispatcher} eventDispatcher The event dispatcher.
 * @param {Object} options The extra task-related arguments.
 *
 * @constructor
 */
function Task(client, eventDispatcher, options) {
    /**
     * 可以被 abort 的 promise 对象
     *
     * @type {Promise}
     */
    this.xhrRequesting = null;

    /**
     * 标记一下是否是人为中断了
     *
     * @type {boolean}
     */
    this.aborted = false;

    this.networkInfo = null;

    this.client = client;
    this.eventDispatcher = eventDispatcher;
    this.options = options;
}

function abstractMethod() {
    throw new Error('unimplemented method.');
}

/**
 * 开始上传任务
 */
Task.prototype.start = abstractMethod;

/**
 * 暂停上传
 */
Task.prototype.pause = abstractMethod;

/**
 * 恢复暂停
 */
Task.prototype.resume = abstractMethod;

Task.prototype.setNetworkInfo = function (networkInfo) {
    this.networkInfo = networkInfo;
};

/**
 * 终止上传任务
 */
Task.prototype.abort = function () {
    if (this.xhrRequesting
        && typeof this.xhrRequesting.abort === 'function') {
        this.aborted = true;
        this.xhrRequesting.abort();
        this.xhrRequesting = null;
    }
};

module.exports = Task;

},{}],31:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file uploader.js
 * @author leeight
 */

var Q = require(44);
var u = require(46);
var utils = require(32);
var events = require(24);
var kDefaultOptions = require(23);
var PutObjectTask = require(27);
var MultipartTask = require(25);
var StsTokenManager = require(29);
var NetworkInfo = require(26);

var Auth = require(15);
var BosClient = require(17);

/**
 * BCE BOS Uploader
 *
 * @constructor
 * @param {Object|string} options 配置参数
 */
function Uploader(options) {
    if (u.isString(options)) {
        // 支持简便的写法，可以从 DOM 里面分析相关的配置.
        options = u.extend({
            browse_button: options,
            auto_start: true
        }, $(options).data());
    }

    var runtimeOptions = {};
    this.options = u.extend({}, kDefaultOptions, runtimeOptions, options);
    this.options.max_file_size = utils.parseSize(this.options.max_file_size);
    this.options.bos_multipart_min_size
        = utils.parseSize(this.options.bos_multipart_min_size);
    this.options.chunk_size = utils.parseSize(this.options.chunk_size);

    var credentials = this.options.bos_credentials;
    if (!credentials && this.options.bos_ak && this.options.bos_sk) {
        this.options.bos_credentials = {
            ak: this.options.bos_ak,
            sk: this.options.bos_sk
        };
    }

    /**
     * @type {BosClient}
     */
    this.client = new BosClient({
        endpoint: utils.normalizeEndpoint(this.options.bos_endpoint),
        credentials: this.options.bos_credentials,
        sessionToken: this.options.uptoken
    });

    /**
     * 需要等待上传的文件列表，每次上传的时候，从这里面删除
     * 成功或者失败都不会再放回去了
     * @param {Array.<File>}
     */
    this._files = [];

    /**
     * 正在上传的文件列表.
     *
     * @type {Object.<string, File>}
     */
    this._uploadingFiles = {};

    /**
     * 是否被中断了，比如 this.stop
     * @type {boolean}
     */
    this._abort = false;

    /**
     * 是否处于上传的过程中，也就是正在处理 this._files 队列的内容.
     * @type {boolean}
     */
    this._working = false;

    /**
     * 是否支持xhr2
     * @type {boolean}
     */
    this._xhr2Supported = utils.isXhr2Supported();

    this._networkInfo = new NetworkInfo();

    this._init();
}

Uploader.prototype._getCustomizedSignature = function (uptokenUrl) {
    var options = this.options;
    var timeout = options.uptoken_timeout || options.uptoken_jsonp_timeout;
    var viaJsonp = options.uptoken_via_jsonp;

    return function (_, httpMethod, path, params, headers) {
        if (/\bed=([\w\.]+)\b/.test(location.search)) {
            headers.Host = RegExp.$1;
        }

        if (u.isArray(options.auth_stripped_headers)) {
            headers = u.omit(headers, options.auth_stripped_headers);
        }

        var deferred = Q.defer();
        $.ajax({
            url: uptokenUrl,
            jsonp: viaJsonp ? 'callback' : false,
            dataType: viaJsonp ? 'jsonp' : 'json',
            timeout: timeout,
            data: {
                httpMethod: httpMethod,
                path: path,
                // delay: ~~(Math.random() * 10),
                queries: JSON.stringify(params || {}),
                headers: JSON.stringify(headers || {})
            },
            error: function () {
                deferred.reject(new Error('Get authorization timeout (' + timeout + 'ms).'));
            },
            success: function (payload) {
                if (payload.statusCode === 200 && payload.signature) {
                    deferred.resolve(payload.signature, payload.xbceDate);
                }
                else {
                    deferred.reject(new Error('createSignature failed, statusCode = ' + payload.statusCode));
                }
            }
        });
        return deferred.promise;
    };
};

/**
 * 调用 this.options.init 里面配置的方法
 *
 * @param {string} methodName 方法名称
 * @param {Array.<*>} args 调用时候的参数.
 * @param {boolean=} throwErrors 如果发生异常的时候，是否需要抛出来
 * @return {*} 事件的返回值.
 */
Uploader.prototype._invoke = function (methodName, args, throwErrors) {
    var init = this.options.init || this.options.Init;
    if (!init) {
        return;
    }

    var method = init[methodName];
    if (typeof method !== 'function') {
        return;
    }

    try {
        var up = null;
        args = args == null ? [up] : [up].concat(args);
        return method.apply(null, args);
    }
    catch (ex) {
        if (throwErrors === true) {
            return Q.reject(ex);
        }
    }
};

/**
 * 初始化控件.
 */
Uploader.prototype._init = function () {
    var options = this.options;
    var accept = options.accept;

    var btnElement = $(options.browse_button);
    var nodeName = btnElement.prop('nodeName');
    if (nodeName !== 'INPUT') {
        var elementContainer = btnElement;

        // 如果本身不是 <input type="file" />，自动追加一个上去
        // 1. options.browse_button 后面追加一个元素 <div><input type="file" /></div>
        // 2. btnElement.parent().css('position', 'relative');
        // 3. .bce-bos-uploader-input-container 用来自定义自己的样式
        var width = elementContainer.outerWidth();
        var height = elementContainer.outerHeight();

        var inputElementContainer = $('<div class="bce-bos-uploader-input-container"><input type="file" /></div>');
        inputElementContainer.css({
            'position': 'absolute',
            'top': 0, 'left': 0,
            'width': width, 'height': height,
            'overflow': 'hidden',
            // 如果支持 xhr2，把 input[type=file] 放到按钮的下面，通过主动调用 file.click() 触发
            // 如果不支持xhr2, 把 input[type=file] 放到按钮的上面，通过用户主动点击 input[type=file] 触发
            'z-index': this._xhr2Supported ? 99 : 100
        });
        inputElementContainer.find('input').css({
            'position': 'absolute',
            'top': 0, 'left': 0,
            'width': '100%', 'height': '100%',
            'font-size': '999px',
            'opacity': 0
        });
        elementContainer.css({
            'position': 'relative',
            'z-index': this._xhr2Supported ? 100 : 99
        });
        elementContainer.after(inputElementContainer);
        elementContainer.parent().css('position', 'relative');

        // 把 browse_button 修改为当前生成的那个元素
        options.browse_button = inputElementContainer.find('input');

        if (this._xhr2Supported) {
            elementContainer.click(function () {
                options.browse_button.click();
            });
        }
    }

    var self = this;
    if (!this._xhr2Supported
        && typeof mOxie !== 'undefined'
        && u.isFunction(mOxie.FileInput)) {
        // https://github.com/moxiecode/moxie/wiki/FileInput
        // mOxie.FileInput 只支持
        // [+]: browse_button, accept multiple, directory, file
        // [x]: container, required_caps
        var fileInput = new mOxie.FileInput({
            runtime_order: 'flash,html4',
            browse_button: $(options.browse_button).get(0),
            swf_url: options.flash_swf_url,
            accept: utils.expandAcceptToArray(accept),
            multiple: options.multi_selection,
            directory: options.dir_selection,
            file: 'file'      // PostObject接口要求固定是 'file'
        });

        fileInput.onchange = u.bind(this._onFilesAdded, this);
        fileInput.onready = function () {
            self._initEvents();
            self._invoke(events.kPostInit);
        };

        fileInput.init();
    }

    var promise = options.bos_credentials
        ? Q.resolve()
        : self.refreshStsToken();

    promise.then(function () {
        if (options.bos_credentials) {
            self.client.createSignature = function (_, httpMethod, path, params, headers) {
                var credentials = _ || this.config.credentials;
                return Q.fcall(function () {
                    var auth = new Auth(credentials.ak, credentials.sk);
                    return auth.generateAuthorization(httpMethod, path, params, headers);
                });
            };
        }
        else if (options.uptoken_url && options.get_new_uptoken === true) {
            // 服务端动态签名的方式
            self.client.createSignature = self._getCustomizedSignature(options.uptoken_url);
        }

        if (self._xhr2Supported) {
            // 对于不支持 xhr2 的情况，会在 onready 的时候去触发事件
            self._initEvents();
            self._invoke(events.kPostInit);
        }
    })["catch"](function (error) {
        self._invoke(events.kError, [error]);
    });
};

Uploader.prototype._initEvents = function () {
    var options = this.options;

    if (this._xhr2Supported) {
        var btn = $(options.browse_button);
        if (btn.attr('multiple') == null) {
            // 如果用户没有显示的设置过 multiple，使用 multi_selection 的设置
            // 否则保留 <input multiple /> 的内容
            btn.attr('multiple', !!options.multi_selection);
        }
        btn.on('change', u.bind(this._onFilesAdded, this));

        var accept = options.accept;
        if (accept != null) {
            // Safari 只支持 mime-type
            // Chrome 支持 mime-type 和 exts
            // Firefox 只支持 exts
            // NOTE: exts 必须有 . 这个前缀，例如 .txt 是合法的，txt 是不合法的
            var exts = utils.expandAccept(accept);
            var isSafari = /Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor);
            if (isSafari) {
                exts = utils.extToMimeType(exts);
            }
            btn.attr('accept', exts);
        }

        if (options.dir_selection) {
            btn.attr('directory', true);
            btn.attr('mozdirectory', true);
            btn.attr('webkitdirectory', true);
        }
    }

    this.client.on('progress', u.bind(this._onUploadProgress, this));
    // XXX 必须绑定 error 的处理函数，否则会 throw new Error
    this.client.on('error', u.bind(this._onError, this));

    // $(window).on('online', u.bind(this._handleOnlineStatus, this));
    // $(window).on('offline', u.bind(this._handleOfflineStatus, this));

    if (!this._xhr2Supported) {
        // 如果浏览器不支持 xhr2，那么就切换到 mOxie.XMLHttpRequest
        // 但是因为 mOxie.XMLHttpRequest 无法发送 HEAD 请求，无法获取 Response Headers，
        // 因此 getObjectMetadata实际上无法正常工作，因此我们需要：
        // 1. 让 BOS 新增 REST API，在 GET 的请求的同时，把 x-bce-* 放到 Response Body 返回
        // 2. 临时方案：新增一个 Relay 服务，实现方案 1
        //    GET /bj.bcebos.com/v1/bucket/object?httpMethod=HEAD
        //    Host: relay.efe.tech
        //    Authorization: xxx
        // options.bos_relay_server
        // options.swf_url
        this.client.sendHTTPRequest = u.bind(utils.fixXhr(this.options, true), this.client);
    }
};

Uploader.prototype._filterFiles = function (candidates) {
    var self = this;

    // 如果 maxFileSize === 0 就说明不限制大小
    var maxFileSize = this.options.max_file_size;

    var files = u.filter(candidates, function (file) {
        if (maxFileSize > 0 && file.size > maxFileSize) {
            self._invoke(events.kFileFiltered, [file]);
            return false;
        }

        // TODO
        // 检查后缀之类的

        return true;
    });

    return this._invoke(events.kFilesFilter, [files]) || files;
};

Uploader.prototype._onFilesAdded = function (e) {
    var files = e.target.files;
    if (!files) {
        // IE7, IE8 低版本浏览器的处理
        var name = e.target.value.split(/[\/\\]/).pop();
        files = [
            {name: name, size: 0}
        ];
    }
    files = this._filterFiles(files);
    if (u.isArray(files) && files.length) {
        this.addFiles(files);
    }

    if (this.options.auto_start) {
        this.start();
    }
};

Uploader.prototype._onError = function (e) {
};

/**
 * 处理上传进度的回掉函数.
 * 1. 这里要区分文件的上传还是分片的上传，分片的上传是通过 partNumber 和 uploadId 的组合来判断的
 * 2. IE6,7,8,9下面，是不需要考虑的，因为不会触发这个事件，而是直接在 _sendPostRequest 触发 kUploadProgress 了
 * 3. 其它情况下，我们判断一下 Request Body 的类型是否是 Blob，从而避免对于其它类型的请求，触发 kUploadProgress
 *    例如：HEAD，GET，POST(InitMultipart) 的时候，是没必要触发 kUploadProgress 的
 *
 * @param {Object} e  Progress Event 对象.
 * @param {Object} httpContext sendHTTPRequest 的参数
 */
Uploader.prototype._onUploadProgress = function (e, httpContext) {
    var args = httpContext.args;
    var file = args.body;

    if (!utils.isBlob(file)) {
        return;
    }

    var progress = e.lengthComputable
        ? e.loaded / e.total
        : 0;
    var delta = e.loaded - file._previousLoaded;
    this._networkInfo.loadedBytes += delta;
    this._invoke(events.kNetworkSpeed, this._networkInfo.dump());
    file._previousLoaded = e.loaded;

    var eventType = events.kUploadProgress;
    if (args.params.partNumber && args.params.uploadId) {
        // IE6,7,8,9下面不会有partNumber和uploadId
        // 此时的 file 是 slice 的结果，可能没有自定义的属性
        // 比如 demo 里面的 __id, __mediaId 之类的
        eventType = events.kUploadPartProgress;
        this._invoke(eventType, [file, progress, e]);

        // 然后需要从 file 获取原始的文件（因为 file 此时是一个分片）
        // 之后再触发一次 events.kUploadProgress 的事件
        var uuid = file._parentUUID;
        var originalFile = this._uploadingFiles[uuid];
        var originalFileProgress = 0;
        if (originalFile) {
            originalFile._previousLoaded += delta;
            originalFileProgress = Math.min(originalFile._previousLoaded / originalFile.size, 1);
            this._invoke(events.kUploadProgress, [originalFile, originalFileProgress, null]);
        }
    }
    else {
        this._invoke(eventType, [file, progress, e]);
    }
};

Uploader.prototype.addFiles = function (files) {
    function buildAbortHandler(item, self) {
        return function () {
            item._aborted = true;
            self._invoke(events.kAborted, [null, item]);
        };
    }

    var totalBytes = 0;
    for (var i = 0; i < files.length; i++) {
        var item = files[i];

        // 这里是 abort 的默认实现，开始上传的时候，会改成另外的一种实现方式
        // 默认的实现是为了支持在没有开始上传之前，也可以取消上传的需求
        item.abort = buildAbortHandler(item, this);

        // 内部的 uuid，外部也可以使用，比如 remove(item.uuid) / remove(item)
        item.uuid = utils.uuid();

        totalBytes += item.size;
    }
    this._networkInfo.totalBytes += totalBytes;
    this._files.push.apply(this._files, files);
    this._invoke(events.kFilesAdded, [files]);
};

Uploader.prototype.addFile = function (file) {
    this.addFiles([file]);
};

Uploader.prototype.remove = function (item) {
    if (typeof item === 'string') {
        item = this._uploadingFiles[item] || u.find(this._files, function (file) {
            return file.uuid === item;
        });
    }

    if (item && typeof item.abort === 'function') {
        item.abort();
    }
};

Uploader.prototype.start = function () {
    var self = this;

    if (this._working) {
        return;
    }

    if (this._files.length) {
        this._working = true;
        this._abort = false;
        this._networkInfo.reset();

        var taskParallel = this.options.bos_task_parallel;
        // 这里没有使用 async.eachLimit 的原因是 this._files 可能会被动态的修改
        utils.eachLimit(this._files, taskParallel,
            function (file, callback) {
                file._previousLoaded = 0;
                self._uploadNext(file)
                    .then(function () {
                        // fulfillment
                        delete self._uploadingFiles[file.uuid];
                        callback(null, file);
                    })[
                    "catch"](function () {
                        // rejection
                        delete self._uploadingFiles[file.uuid];
                        callback(null, file);
                    });
            },
            function (error) {
                self._working = false;
                self._files.length = 0;
                self._networkInfo.totalBytes = 0;
                self._invoke(events.kUploadComplete);
            });
    }
};

Uploader.prototype.stop = function () {
    this._abort = true;
    this._working = false;
};

/**
 * 动态设置 Uploader 的某些参数，当前只支持动态的修改
 * bos_credentials, uptoken, bos_bucket, bos_endpoint
 * bos_ak, bos_sk
 *
 * @param {Object} options 用户动态设置的参数（只支持部分）
 */
Uploader.prototype.setOptions = function (options) {
    var supportedOptions = u.pick(options, 'bos_credentials',
        'bos_ak', 'bos_sk', 'uptoken', 'bos_bucket', 'bos_endpoint');
    this.options = u.extend(this.options, supportedOptions);

    var config = this.client && this.client.config;
    if (config) {
        var credentials = null;

        if (options.bos_credentials) {
            credentials = options.bos_credentials;
        }
        else if (options.bos_ak && options.bos_sk) {
            credentials = {
                ak: options.bos_ak,
                sk: options.bos_sk
            };
        }

        if (credentials) {
            this.options.bos_credentials = credentials;
            config.credentials = credentials;
        }
        if (options.uptoken) {
            config.sessionToken = options.uptoken;
        }
        if (options.bos_endpoint) {
            config.endpoint = utils.normalizeEndpoint(options.bos_endpoint);
        }
    }
};

/**
 * 有的用户希望主动更新 sts token，避免过期的问题
 *
 * @return {Promise}
 */
Uploader.prototype.refreshStsToken = function () {
    var self = this;
    var options = self.options;
    var stsMode = true // self._xhr2Supported
        && options.bos_bucket
        && options.uptoken_url
        && options.get_new_uptoken === false;
    if (stsMode) {
        var stm = new StsTokenManager(options);
        return stm.get(options.bos_bucket).then(function (payload) {
            return self.setOptions({
                bos_ak: payload.AccessKeyId,
                bos_sk: payload.SecretAccessKey,
                uptoken: payload.SessionToken
            });
        });
    }
    return Q.resolve();
};

Uploader.prototype._uploadNext = function (file) {
    if (this._abort) {
        this._working = false;
        return Q.resolve();
    }

    if (file._aborted === true) {
        return Q.resolve();
    }

    var throwErrors = true;
    var returnValue = this._invoke(events.kBeforeUpload, [file], throwErrors);
    if (returnValue === false) {
        return Q.resolve();
    }

    var self = this;
    return Q.resolve(returnValue)
        .then(function () {
            return self._uploadNextImpl(file);
        })[
        "catch"](function (error) {
            self._invoke(events.kError, [error, file]);
        });
};

Uploader.prototype._uploadNextImpl = function (file) {
    var self = this;
    var options = this.options;
    var object = file.name;
    var throwErrors = true;

    var defaultTaskOptions = u.pick(options,
        'flash_swf_url', 'max_retries', 'chunk_size', 'retry_interval',
        'bos_multipart_parallel',
        'bos_multipart_auto_continue',
        'bos_multipart_local_key_generator'
    );
    return Q.all([
        this._invoke(events.kKey, [file], throwErrors),
        this._invoke(events.kObjectMetas, [file])
    ]).then(function (array) {
        // options.bos_bucket 可能会被 kKey 事件动态的改变
        var bucket = options.bos_bucket;

        var result = array[0];
        var objectMetas = array[1];

        var multipart = 'auto';
        if (u.isString(result)) {
            object = result;
        }
        else if (u.isObject(result)) {
            bucket = result.bucket || bucket;
            object = result.key || object;

            // 'auto' / 'off'
            multipart = result.multipart || multipart;
        }

        var client = self.client;
        var eventDispatcher = self;
        var taskOptions = u.extend(defaultTaskOptions, {
            file: file,
            bucket: bucket,
            object: object,
            metas: objectMetas
        });

        var TaskConstructor = PutObjectTask;
        if (multipart === 'auto'
            // 对于 moxie.XMLHttpRequest 来说，无法获取 getResponseHeader('ETag')
            // 导致在 completeMultipartUpload 的时候，无法传递正确的参数
            // 因此需要禁止使用 moxie.XMLHttpRequest 使用 MultipartTask
            // 除非用自己本地计算的 md5 作为 getResponseHeader('ETag') 的代替值，不过还是有一些问题：
            // 1. MultipartTask 需要对文件进行分片，但是使用 moxie.XMLHttpRequest 的时候，明显有卡顿的问题（因为 Flash 把整个文件都读取到内存中，然后再分片）
            //    导致处理大文件的时候性能很差
            // 2. 本地计算 md5 需要额外引入库，导致 bce-bos-uploader 的体积变大
            // 综上所述，在使用 moxie 的时候，禁止 MultipartTask
            && self._xhr2Supported
            && file.size > options.bos_multipart_min_size) {
            TaskConstructor = MultipartTask;
        }
        var task = new TaskConstructor(client, eventDispatcher, taskOptions);

        self._uploadingFiles[file.uuid] = file;

        file.abort = function () {
            file._aborted = true;
            return task.abort();
        };

        task.setNetworkInfo(self._networkInfo);
        return task.start();
    });
};

Uploader.prototype.dispatchEvent = function (eventName, eventArguments, throwErrors) {
    if (eventName === events.kAborted
        && eventArguments
        && eventArguments[1]) {
        var file = eventArguments[1];
        if (file.size > 0) {
            var loadedSize = file._previousLoaded || 0;
            this._networkInfo.totalBytes -= (file.size - loadedSize);
            this._invoke(events.kNetworkSpeed, this._networkInfo.dump());
        }
    }
    return this._invoke(eventName, eventArguments, throwErrors);
};

module.exports = Uploader;

},{"15":15,"17":17,"23":23,"24":24,"25":25,"26":26,"27":27,"29":29,"32":32,"44":44,"46":46}],32:[function(require,module,exports){
/**
 * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file utils.js
 * @author leeight
 */

var qsModule = require(45);
var Q = require(44);
var u = require(46);
var helper = require(42);
var Queue = require(28);
var MimeType = require(21);

/**
 * 把文件进行切片，返回切片之后的数组
 *
 * @param {Blob} file 需要切片的大文件.
 * @param {string} uploadId 从服务获取的uploadId.
 * @param {number} chunkSize 分片的大小.
 * @param {string} bucket Bucket Name.
 * @param {string} object Object Name.
 * @return {Array.<Object>}
 */
exports.getTasks = function (file, uploadId, chunkSize, bucket, object) {
    var leftSize = file.size;
    var offset = 0;
    var partNumber = 1;

    var tasks = [];

    while (leftSize > 0) {
        var partSize = Math.min(leftSize, chunkSize);

        tasks.push({
            file: file,
            uploadId: uploadId,
            bucket: bucket,
            object: object,
            partNumber: partNumber,
            partSize: partSize,
            start: offset,
            stop: offset + partSize - 1
        });

        leftSize -= partSize;
        offset += partSize;
        partNumber += 1;
    }

    return tasks;
};

exports.getAppendableTasks = function (fileSize, offset, chunkSize) {
    var leftSize = fileSize - offset;
    var tasks = [];

    while (leftSize) {
        var partSize = Math.min(leftSize, chunkSize);
        tasks.push({
            partSize: partSize,
            start: offset,
            stop: offset + partSize - 1
        });

        leftSize -= partSize;
        offset += partSize;
    }
    return tasks;
};

exports.parseSize = function (size) {
    if (typeof size === 'number') {
        return size;
    }

    // mb MB Mb M
    // kb KB kb k
    // 100
    var pattern = /^([\d\.]+)([mkg]?b?)$/i;
    var match = pattern.exec(size);
    if (!match) {
        return 0;
    }

    var $1 = match[1];
    var $2 = match[2];
    if (/^k/i.test($2)) {
        return $1 * 1024;
    }
    else if (/^m/i.test($2)) {
        return $1 * 1024 * 1024;
    }
    else if (/^g/i.test($2)) {
        return $1 * 1024 * 1024 * 1024;
    }
    return +$1;
};

/**
 * 判断一下浏览器是否支持 xhr2 特性，如果不支持，就 fallback 到 PostObject
 * 来上传文件
 *
 * @return {boolean}
 */
exports.isXhr2Supported = function () {
    // https://github.com/Modernizr/Modernizr/blob/f839e2579da2c6331eaad922ae5cd691aac7ab62/feature-detects/network/xhr2.js
    return 'XMLHttpRequest' in window && 'withCredentials' in new XMLHttpRequest();
};

exports.isAppendable = function (headers) {
    return headers['x-bce-object-type'] === 'Appendable';
};

exports.delay = function (ms) {
    var deferred = Q.defer();
    setTimeout(function () {
        deferred.resolve();
    }, ms);
    return deferred.promise;
};

/**
 * 规范化用户的输入
 *
 * @param {string} endpoint The endpoint will be normalized
 * @return {string}
 */
exports.normalizeEndpoint = function (endpoint) {
    return endpoint.replace(/(\/+)$/, '');
};

exports.getDefaultACL = function (bucket) {
    return {
        accessControlList: [
            {
                service: 'bce:bos',
                region: '*',
                effect: 'Allow',
                resource: [bucket + '/*'],
                permission: ['READ', 'WRITE']
            }
        ]
    };
};

/**
 * 生成uuid
 *
 * @return {string}
 */
exports.uuid = function () {
    var random = (Math.random() * Math.pow(2, 32)).toString(36);
    var timestamp = new Date().getTime();
    return 'u-' + timestamp + '-' + random;
};

/**
 * 生成本地 localStorage 中的key，来存储 uploadId
 * localStorage[key] = uploadId
 *
 * @param {Object} option 一些可以用来计算key的参数.
 * @param {string} generator 内置的只有 default 和 md5
 * @return {Promise}
 */
exports.generateLocalKey = function (option, generator) {
    if (generator === 'default') {
        return Q.resolve([
            option.blob.name, option.blob.size,
            option.chunkSize, option.bucket,
            option.object
        ].join('&'));
    }
    return Q.resolve(null);
};

exports.getDefaultPolicy = function (bucket) {
    if (bucket == null) {
        return null;
    }

    var now = new Date().getTime();

    // 默认是 24小时 之后到期
    var expiration = new Date(now + 24 * 60 * 60 * 1000);
    var utcDateTime = helper.toUTCString(expiration);

    return {
        expiration: utcDateTime,
        conditions: [
            {bucket: bucket}
        ]
    };
};

/**
 * 根据key获取localStorage中的uploadId
 *
 * @param {string} key 需要查询的key
 * @return {string}
 */
exports.getUploadId = function (key) {
    return localStorage.getItem(key);
};


/**
 * 根据key设置localStorage中的uploadId
 *
 * @param {string} key 需要查询的key
 * @param {string} uploadId 需要设置的uploadId
 */
exports.setUploadId = function (key, uploadId) {
    localStorage.setItem(key, uploadId);
};

/**
 * 根据key删除localStorage中的uploadId
 *
 * @param {string} key 需要查询的key
 */
exports.removeUploadId = function (key) {
    localStorage.removeItem(key);
};

/**
 * 取得已上传分块的etag
 *
 * @param {number} partNumber 分片序号.
 * @param {Array} existParts 已上传完成的分片信息.
 * @return {string} 指定分片的etag
 */
function getPartEtag(partNumber, existParts) {
    var matchParts = u.filter(existParts || [], function (part) {
        return +part.partNumber === partNumber;
    });
    return matchParts.length ? matchParts[0].eTag : null;
}

/**
 * 因为 listParts 会返回 partNumber 和 etag 的对应关系
 * 所以 listParts 返回的结果，给 tasks 中合适的元素设置 etag 属性，上传
 * 的时候就可以跳过这些 part
 *
 * @param {Array.<Object>} tasks 本地切分好的任务.
 * @param {Array.<Object>} parts 服务端返回的已经上传的parts.
 */
exports.filterTasks = function (tasks, parts) {
    u.each(tasks, function (task) {
        var partNumber = task.partNumber;
        var etag = getPartEtag(partNumber, parts);
        if (etag) {
            task.etag = etag;
        }
    });
};

/**
 * 把用户输入的配置转化成 html5 和 flash 可以接收的内容.
 *
 * @param {string|Array} accept 支持数组和字符串的配置
 * @return {string}
 */
exports.expandAccept = function (accept) {
    var exts = [];

    if (u.isArray(accept)) {
        // Flash要求的格式
        u.each(accept, function (item) {
            if (item.extensions) {
                exts.push.apply(exts, item.extensions.split(','));
            }
        });
    }
    else if (u.isString(accept)) {
        exts = accept.split(',');
    }

    // 为了保证兼容性，把 mimeTypes 和 exts 都返回回去
    exts = u.map(exts, function (ext) {
        return /^\./.test(ext) ? ext : ('.' + ext);
    });

    return exts.join(',');
};

exports.extToMimeType = function (exts) {
    var mimeTypes = u.map(exts.split(','), function (ext) {
        if (ext.indexOf('/') !== -1) {
            return ext;
        }
        return MimeType.guess(ext);
    });

    return mimeTypes.join(',');
};

exports.expandAcceptToArray = function (accept) {
    if (!accept || u.isArray(accept)) {
        return accept;
    }

    if (u.isString(accept)) {
        return [
            {title: 'All files', extensions: accept}
        ];
    }

    return [];
};

/**
 * 转化一下 bos url 的格式
 * http://bj.bcebos.com/v1/${bucket}/${object} -> http://${bucket}.bj.bcebos.com/v1/${object}
 *
 * @param {string} url 需要转化的URL.
 * @return {string}
 */
exports.transformUrl = function (url) {
    var pattern = /(https?:)\/\/([^\/]+)\/([^\/]+)\/([^\/]+)/;
    return url.replace(pattern, function (_, protocol, host, $3, $4) {
        if (/^v\d$/.test($3)) {
            // /v1/${bucket}/...
            return protocol + '//' + $4 + '.' + host + '/' + $3;
        }
        // /${bucket}/...
        return protocol + '//' + $3 + '.' + host + '/' + $4;
    });
};

exports.isBlob = function (body) {
    var blobCtor = null;

    if (typeof Blob !== 'undefined') {
        // Chrome Blob === 'function'
        // Safari Blob === 'undefined'
        blobCtor = Blob;
    }
    else if (typeof mOxie !== 'undefined' && u.isFunction(mOxie.Blob)) {
        blobCtor = mOxie.Blob;
    }
    else {
        return false;
    }

    return body instanceof blobCtor;
};

exports.now = function () {
    return new Date().getTime();
};

exports.toDHMS = function (seconds) {
    var days = 0;
    var hours = 0;
    var minutes = 0;

    if (seconds >= 60) {
        minutes = ~~(seconds / 60);
        seconds = seconds - minutes * 60;
    }

    if (minutes >= 60) {
        hours = ~~(minutes / 60);
        minutes = minutes - hours * 60;
    }

    if (hours >= 24) {
        days = ~~(hours / 24);
        hours = hours - days * 24;
    }

    return {DD: days, HH: hours, MM: minutes, SS: seconds};
};

function parseHost(url) {
    var match = /^\w+:\/\/([^\/]+)/.exec(url);
    return match && match[1];
}

exports.fixXhr = function (options, isBos) {
    return function (httpMethod, resource, args, config) {
        var client = this;
        var endpointHost = parseHost(config.endpoint);

        // x-bce-date 和 Date 二选一，是必须的
        // 但是 Flash 无法设置 Date，因此必须设置 x-bce-date
        args.headers['x-bce-date'] = helper.toUTCString(new Date());
        args.headers.host = endpointHost;

        // Flash 的缓存貌似比较厉害，强制请求新的
        // XXX 好像服务器端不会把 .stamp 这个参数加入到签名的计算逻辑里面去
        args.params['.stamp'] = new Date().getTime();

        // 只有 PUT 才会触发 progress 事件
        var originalHttpMethod = httpMethod;

        if (httpMethod === 'PUT') {
            // PutObject PutParts 都可以用 POST 协议，而且 Flash 也只能用 POST 协议
            httpMethod = 'POST';
        }

        var xhrUri;
        var xhrMethod = httpMethod;
        var xhrBody = args.body;
        if (httpMethod === 'HEAD') {
            // 因为 Flash 的 URLRequest 只能发送 GET 和 POST 请求
            // getObjectMeta需要用HEAD请求，但是 Flash 无法发起这种请求
            // 所需需要用 relay 中转一下
            // XXX 因为 bucket 不可能是 private，否则 crossdomain.xml 是无法读取的
            // 所以这个接口请求的时候，可以不需要 authorization 字段
            var relayServer = exports.normalizeEndpoint(options.bos_relay_server);
            xhrUri = relayServer + '/' + endpointHost + resource;

            args.params.httpMethod = httpMethod;

            xhrMethod = 'POST';
        }
        else if (isBos === true) {
            xhrUri = exports.transformUrl(config.endpoint + resource);
            resource = xhrUri.replace(/^\w+:\/\/[^\/]+\//, '/');
            args.headers.host = parseHost(xhrUri);
        }
        else {
            xhrUri = config.endpoint + resource;
        }

        if (xhrMethod === 'POST' && !xhrBody) {
            // 必须要有 BODY 才能是 POST，否则你设置了也没有
            // 而且必须是 POST 才可以设置自定义的header，GET不行
            xhrBody = '{"FORCE_POST": true}';
        }

        var deferred = Q.defer();

        var xhr = new mOxie.XMLHttpRequest();

        xhr.onload = function () {
            var response = null;
            try {
                response = JSON.parse(xhr.response || '{}');
                response.location = xhrUri;
            }
            catch (ex) {
                response = {
                    location: xhrUri
                };
            }

            if (xhr.status >= 200 && xhr.status < 300) {
                if (httpMethod === 'HEAD') {
                    deferred.resolve(response);
                }
                else {
                    deferred.resolve({
                        http_headers: {},
                        body: response
                    });
                }
            }
            else {
                deferred.reject({
                    status_code: xhr.status,
                    message: response.message || '',
                    code: response.code || '',
                    request_id: response.requestId || ''
                });
            }
        };

        xhr.onerror = function (error) {
            deferred.reject(error);
        };

        if (xhr.upload) {
            // FIXME(分片上传的逻辑和xxx的逻辑不一样)
            xhr.upload.onprogress = function (e) {
                if (originalHttpMethod === 'PUT') {
                    // POST, HEAD, GET 之类的不需要触发 progress 事件
                    // 否则导致页面的逻辑混乱
                    e.lengthComputable = true;

                    var httpContext = {
                        httpMethod: originalHttpMethod,
                        resource: resource,
                        args: args,
                        config: config,
                        xhr: xhr
                    };

                    client.emit('progress', e, httpContext);
                }
            };
        }

        var promise = client.createSignature(client.config.credentials,
            httpMethod, resource, args.params, args.headers);
        promise.then(function (authorization, xbceDate) {
            if (authorization) {
                args.headers.authorization = authorization;
            }

            if (xbceDate) {
                args.headers['x-bce-date'] = xbceDate;
            }

            var qs = qsModule.stringify(args.params);
            if (qs) {
                xhrUri += '?' + qs;
            }

            xhr.open(xhrMethod, xhrUri, true);

            for (var key in args.headers) {
                if (!args.headers.hasOwnProperty(key)
                    || /(host|content\-length)/i.test(key)) {
                    continue;
                }
                var value = args.headers[key];
                xhr.setRequestHeader(key, value);
            }

            xhr.send(xhrBody, {
                runtime_order: 'flash',
                swf_url: options.flash_swf_url
            });
        })[
        "catch"](function (error) {
            deferred.reject(error);
        });

        return deferred.promise;
    };
};


exports.eachLimit = function (tasks, taskParallel, executer, done) {
    var runningCount = 0;
    var aborted = false;
    var fin = false;      // done 只能被调用一次.
    var queue = new Queue(tasks);

    function infiniteLoop() {
        var task = queue.dequeue();
        if (!task) {
            return;
        }

        runningCount++;
        executer(task, function (error) {
            runningCount--;

            if (error) {
                // 一旦有报错，终止运行
                aborted = true;
                fin = true;
                done(error);
            }
            else {
                if (!queue.isEmpty() && !aborted) {
                    // 队列还有内容
                    setTimeout(infiniteLoop, 0);
                }
                else if (runningCount <= 0) {
                    // 队列空了，而且没有运行中的任务了
                    if (!fin) {
                        fin = true;
                        done();
                    }
                }
            }
        });
    }

    taskParallel = Math.min(taskParallel, queue.size());
    for (var i = 0; i < taskParallel; i++) {
        infiniteLoop();
    }
};

exports.inherits = function (ChildCtor, ParentCtor) {
    return require(47).inherits(ChildCtor, ParentCtor);
};

exports.guessContentType = function (file, opt_ignoreCharset) {
    var contentType = file.type;
    if (!contentType) {
        var object = file.name;
        var ext = object.split(/\./g).pop();
        contentType = MimeType.guess(ext);
    }

    // Firefox在POST的时候，Content-Type 一定会有Charset的，因此
    // 这里不管3721，都加上.
    if (!opt_ignoreCharset && !/charset=/.test(contentType)) {
        contentType += '; charset=UTF-8';
    }

    return contentType;
};

},{"21":21,"28":28,"42":42,"44":44,"45":45,"46":46,"47":47}],33:[function(require,module,exports){
/**
 * @file vendor/Buffer.js
 * @author leeight
 */

/**
 * Buffer
 *
 * @class
 */
function Buffer() {
}

Buffer.byteLength = function (data) {
    // http://stackoverflow.com/questions/5515869/string-length-in-bytes-in-javascript
    var m = encodeURIComponent(data).match(/%[89ABab]/g);
    return data.length + (m ? m.length : 0);
};

module.exports = Buffer;











},{}],34:[function(require,module,exports){
/**
 * @file Promise.js
 * @author ??
 */

(function (root) {

    // Store setTimeout reference so promise-polyfill will be unaffected by
    // other code modifying setTimeout (like sinon.useFakeTimers())
    var setTimeoutFunc = setTimeout;

    function noop() {
    }

    // Polyfill for Function.prototype.bind
    function bind(fn, thisArg) {
        return function () {
            fn.apply(thisArg, arguments);
        };
    }

    /**
     * Promise
     *
     * @param {Function} fn The executor.
     * @class
     */
    function Promise(fn) {
        if (typeof this !== 'object') {
            throw new TypeError('Promises must be constructed via new');
        }

        if (typeof fn !== 'function') {
            throw new TypeError('not a function');
        }

        this._state = 0;
        this._handled = false;
        this._value = undefined;
        this._deferreds = [];

        doResolve(fn, this);
    }

    function handle(self, deferred) {
        while (self._state === 3) {
            self = self._value;
        }
        if (self._state === 0) {
            self._deferreds.push(deferred);
            return;
        }

        self._handled = true;
        Promise._immediateFn(function () {
            var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
            if (cb === null) {
                (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
                return;
            }

            var ret;
            try {
                ret = cb(self._value);
            }
            catch (e) {
                reject(deferred.promise, e);
                return;
            }
            resolve(deferred.promise, ret);
        });
    }

    function resolve(self, newValue) {
        try {
            // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
            if (newValue === self) {
                throw new TypeError('A promise cannot be resolved with itself.');
            }

            if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
                var then = newValue.then;
                if (newValue instanceof Promise) {
                    self._state = 3;
                    self._value = newValue;
                    finale(self);
                    return;
                }
                else if (typeof then === 'function') {
                    doResolve(bind(then, newValue), self);
                    return;
                }
            }

            self._state = 1;
            self._value = newValue;
            finale(self);
        }
        catch (e) {
            reject(self, e);
        }
    }

    function reject(self, newValue) {
        self._state = 2;
        self._value = newValue;
        finale(self);
    }

    function finale(self) {
        if (self._state === 2 && self._deferreds.length === 0) {
            Promise._immediateFn(function () {
                if (!self._handled) {
                    Promise._unhandledRejectionFn(self._value);
                }

            });
        }

        for (var i = 0, len = self._deferreds.length; i < len; i++) {
            handle(self, self._deferreds[i]);
        }
        self._deferreds = null;
    }

    /**
     * Handler
     *
     * @class
     * @param {*} onFulfilled The onFulfilled.
     * @param {*} onRejected The onRejected.
     * @param {*} promise The promise.
     */
    function Handler(onFulfilled, onRejected, promise) {
        this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
        this.onRejected = typeof onRejected === 'function' ? onRejected : null;
        this.promise = promise;
    }

    /**
     * Take a potentially misbehaving resolver function and make sure
     * onFulfilled and onRejected are only called once.
     *
     * Makes no guarantees about asynchrony.
     *
     * @param {Function} fn The fn.
     * @param {*} self The context.
     */
    function doResolve(fn, self) {
        var done = false;
        try {
            fn(function (value) {
                if (done) {
                    return;
                }

                done = true;
                resolve(self, value);
            }, function (reason) {
                if (done) {
                    return;
                }

                done = true;
                reject(self, reason);
            });
        }
        catch (ex) {
            if (done) {
                return;
            }

            done = true;
            reject(self, ex);
        }
    }

    Promise.prototype["catch"] = function (onRejected) {   // eslint-disable-line
        return this.then(null, onRejected);
    };

    Promise.prototype.then = function (onFulfilled, onRejected) {   // eslint-disable-line
        var prom = new (this.constructor)(noop);

        handle(this, new Handler(onFulfilled, onRejected, prom));
        return prom;
    };

    Promise.all = function (arr) {
        var args = Array.prototype.slice.call(arr);

        return new Promise(function (resolve, reject) {
            if (args.length === 0) {
                return resolve([]);
            }

            var remaining = args.length;

            function res(i, val) {
                try {
                    if (val && (typeof val === 'object' || typeof val === 'function')) {
                        var then = val.then;
                        if (typeof then === 'function') {
                            then.call(val, function (val) {
                                res(i, val);
                            }, reject);
                            return;
                        }
                    }

                    args[i] = val;
                    if (--remaining === 0) {
                        resolve(args);
                    }

                }
                catch (ex) {
                    reject(ex);
                }
            }

            for (var i = 0; i < args.length; i++) {
                res(i, args[i]);
            }
        });
    };

    Promise.resolve = function (value) {
        if (value && typeof value === 'object' && value.constructor === Promise) {
            return value;
        }

        return new Promise(function (resolve) {
            resolve(value);
        });
    };

    Promise.reject = function (value) {
        return new Promise(function (resolve, reject) {
            reject(value);
        });
    };

    Promise.race = function (values) {
        return new Promise(function (resolve, reject) {
            for (var i = 0, len = values.length; i < len; i++) {
                values[i].then(resolve, reject);
            }
        });
    };

    // Use polyfill for setImmediate for performance gains
    Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) {
        setImmediate(fn);
    }) || function (fn) {
        setTimeoutFunc(fn, 0);
    };

    Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
        if (typeof console !== 'undefined' && console) {
            console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
        }

    };

    /**
     * Set the immediate function to execute callbacks
     *
     * @param {Function} fn Function to execute
     * @deprecated
     */
    Promise._setImmediateFn = function _setImmediateFn(fn) {
        Promise._immediateFn = fn;
    };

    /**
     * Change the function to execute on unhandled rejection
     *
     * @param {Function} fn Function to execute on unhandled rejection
     * @deprecated
     */
    Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
        Promise._unhandledRejectionFn = fn;
    };

    if (typeof module !== 'undefined' && module.exports) {
        module.exports = Promise;
    }
    else if (!root.Promise) {
        root.Promise = Promise;
    }

})(this);

},{}],35:[function(require,module,exports){
/**
 * @file vendor/async.js
 * @author leeight
 */

exports.mapLimit = require(2);

},{"2":2}],36:[function(require,module,exports){
/**
 * @file core.js
 * @author ???
 */

/**
 * Local polyfil of Object.create
 */
var create = Object.create || (function () {
    function F() {    // eslint-disable-line
    }

    return function (obj) {
        var subtype;

        F.prototype = obj;

        subtype = new F();

        F.prototype = null;

        return subtype;
    };
}());

/**
 * CryptoJS namespace.
 */
var C = {};

/**
 * Algorithm namespace.
 */
var C_algo = C.algo = {};

/**
 * Library namespace.
 */
var C_lib = C.lib = {};

/**
  * Base object for prototypal inheritance.
  */
var Base = C_lib.Base = (function () {

    return {

        /**
          * Creates a new object that inherits from this object.
          *
          * @param {Object} overrides Properties to copy into the new object.
          *
          * @return {Object} The new object.
          *
          * @static
          *
          * @example
          *
          *     var MyType = CryptoJS.lib.Base.extend({
          *         field: 'value',
          *
          *         method: function () {
          *         }
          *     });
          */
        extend: function (overrides) {
            // Spawn
            var subtype = create(this);

            // Augment
            if (overrides) {
                subtype.mixIn(overrides);
            }

            // Create default initializer
            if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
                subtype.init = function () {
                    subtype.$super.init.apply(this, arguments);
                };
            }

            // Initializer's prototype is the subtype object
            subtype.init.prototype = subtype;

            // Reference supertype
            subtype.$super = this;

            return subtype;
        },

        /**
          * Extends this object and runs the init method.
          * Arguments to create() will be passed to init().
          *
          * @return {Object} The new object.
          *
          * @static
          *
          * @example
          *
          *     var instance = MyType.create();
          */
        create: function () {
            var instance = this.extend();
            instance.init.apply(instance, arguments);

            return instance;
        },

        /**
          * Initializes a newly created object.
          * Override this method to add some logic when your objects are created.
          *
          * @example
          *
          *     var MyType = CryptoJS.lib.Base.extend({
          *         init: function () {
          *             // ...
          *         }
          *     });
          */
        init: function () {},

        /**
          * Copies properties into this object.
          *
          * @param {Object} properties The properties to mix in.
          *
          * @example
          *
          *     MyType.mixIn({
          *         field: 'value'
          *     });
          */
        mixIn: function (properties) {
            for (var propertyName in properties) {
                if (properties.hasOwnProperty(propertyName)) {
                    this[propertyName] = properties[propertyName];
                }

            }

            // IE won't copy toString using the loop above
            if (properties.hasOwnProperty('toString')) {
                this.toString = properties.toString;
            }

        },

        /**
          * Creates a copy of this object.
          *
          * @return {Object} The clone.
          *
          * @example
          *
          *     var clone = instance.clone();
          */
        clone: function () {
            return this.init.prototype.extend(this);
        }
    };
}());

/**
  * An array of 32-bit words.
  *
  * @property {Array} words The array of 32-bit words.
  * @property {number} sigBytes The number of significant bytes in this word array.
  */
var WordArray = C_lib.WordArray = Base.extend({

    /**
      * Initializes a newly created word array.
      *
      * @param {Array} words (Optional) An array of 32-bit words.
      * @param {number} sigBytes (Optional) The number of significant bytes in the words.
      *
      * @example
      *
      *     var wordArray = CryptoJS.lib.WordArray.create();
      *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
      *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
      */
    init: function (words, sigBytes) {
        words = this.words = words || [];

        if (sigBytes != undefined) {    // eslint-disable-line
            this.sigBytes = sigBytes;
        }
        else {
            this.sigBytes = words.length * 4;
        }
    },

    /**
      * Converts this word array to a string.
      *
      * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
      *
      * @return {string} The stringified word array.
      *
      * @example
      *
      *     var string = wordArray + '';
      *     var string = wordArray.toString();
      *     var string = wordArray.toString(CryptoJS.enc.Utf8);
      */
    toString: function (encoder) {
        return (encoder || Hex).stringify(this);    // eslint-disable-line
    },

    /**
      * Concatenates a word array to this word array.
      *
      * @param {WordArray} wordArray The word array to append.
      *
      * @return {WordArray} This word array.
      *
      * @example
      *
      *     wordArray1.concat(wordArray2);
      */
    concat: function (wordArray) {
        // Shortcuts
        var thisWords = this.words;
        var thatWords = wordArray.words;
        var thisSigBytes = this.sigBytes;
        var thatSigBytes = wordArray.sigBytes;

        // Clamp excess bits
        this.clamp();


        var i;

        // Concat
        if (thisSigBytes % 4) {
            // Copy one byte at a time
            for (i = 0; i < thatSigBytes; i++) {
                var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
            }
        }
        else {
            // Copy one word at a time
            for (i = 0; i < thatSigBytes; i += 4) {
                thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
            }
        }
        this.sigBytes += thatSigBytes;

        // Chainable
        return this;
    },

    /**
      * Removes insignificant bits.
      *
      * @example
      *
      *     wordArray.clamp();
      */
    clamp: function () {
        // Shortcuts
        var words = this.words;
        var sigBytes = this.sigBytes;

        // Clamp
        words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
        words.length = Math.ceil(sigBytes / 4);
    },

    /**
      * Creates a copy of this word array.
      *
      * @return {WordArray} The clone.
      *
      * @example
      *
      *     var clone = wordArray.clone();
      */
    clone: function () {
        var clone = Base.clone.call(this);
        clone.words = this.words.slice(0);

        return clone;
    },

    /**
      * Creates a word array filled with random bytes.
      *
      * @param {number} nBytes The number of random bytes to generate.
      *
      * @return {WordArray} The random word array.
      *
      * @static
      *
      * @example
      *
      *     var wordArray = CryptoJS.lib.WordArray.random(16);
      */
    random: function (nBytes) {
        var words = [];

        var r = function (m_w) {
            var m_z = 0x3ade68b1;
            var mask = 0xffffffff;

            return function () {
                m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
                m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
                var result = ((m_z << 0x10) + m_w) & mask;
                result /= 0x100000000;
                result += 0.5;
                return result * (Math.random() > .5 ? 1 : -1);
            };
        };

        for (var i = 0, rcache; i < nBytes; i += 4) {
            var _r = r((rcache || Math.random()) * 0x100000000);

            rcache = _r() * 0x3ade67b7;
            words.push((_r() * 0x100000000) | 0);
        }

        return new WordArray.init(words, nBytes); // eslint-disable-line
    }
});

/**
  * Encoder namespace.
  */
var C_enc = C.enc = {};

/**
  * Hex encoding strategy.
  */
var Hex = C_enc.Hex = {

    /**
      * Converts a word array to a hex string.
      *
      * @param {WordArray} wordArray The word array.
      *
      * @return {string} The hex string.
      *
      * @static
      *
      * @example
      *
      *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
      */
    stringify: function (wordArray) {
        // Shortcuts
        var words = wordArray.words;
        var sigBytes = wordArray.sigBytes;

        // Convert
        var hexChars = [];
        for (var i = 0; i < sigBytes; i++) {
            var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
            hexChars.push((bite >>> 4).toString(16));
            hexChars.push((bite & 0x0f).toString(16));
        }

        return hexChars.join('');
    },

    /**
      * Converts a hex string to a word array.
      *
      * @param {string} hexStr The hex string.
      *
      * @return {WordArray} The word array.
      *
      * @static
      *
      * @example
      *
      *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
      */
    parse: function (hexStr) {
        // Shortcut
        var hexStrLength = hexStr.length;

        // Convert
        var words = [];
        for (var i = 0; i < hexStrLength; i += 2) {
            words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
        }

        return new WordArray.init(words, hexStrLength / 2);   // eslint-disable-line
    }
};

/**
  * Latin1 encoding strategy.
  */
var Latin1 = C_enc.Latin1 = {

    /**
      * Converts a word array to a Latin1 string.
      *
      * @param {WordArray} wordArray The word array.
      *
      * @return {string} The Latin1 string.
      *
      * @static
      *
      * @example
      *
      *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
      */
    stringify: function (wordArray) {
        // Shortcuts
        var words = wordArray.words;
        var sigBytes = wordArray.sigBytes;

        // Convert
        var latin1Chars = [];
        for (var i = 0; i < sigBytes; i++) {
            var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
            latin1Chars.push(String.fromCharCode(bite));
        }

        return latin1Chars.join('');
    },

    /**
      * Converts a Latin1 string to a word array.
      *
      * @param {string} latin1Str The Latin1 string.
      *
      * @return {WordArray} The word array.
      *
      * @static
      *
      * @example
      *
      *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
      */
    parse: function (latin1Str) {
        // Shortcut
        var latin1StrLength = latin1Str.length;

        // Convert
        var words = [];
        for (var i = 0; i < latin1StrLength; i++) {
            words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
        }

        return new WordArray.init(words, latin1StrLength);    // eslint-disable-line
    }
};

/**
  * UTF-8 encoding strategy.
  */
var Utf8 = C_enc.Utf8 = {

    /**
      * Converts a word array to a UTF-8 string.
      *
      * @param {WordArray} wordArray The word array.
      *
      * @return {string} The UTF-8 string.
      *
      * @static
      *
      * @example
      *
      *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
      */
    stringify: function (wordArray) {
        try {
            return decodeURIComponent(escape(Latin1.stringify(wordArray)));
        }
        catch (e) {
            throw new Error('Malformed UTF-8 data');
        }
    },

    /**
      * Converts a UTF-8 string to a word array.
      *
      * @param {string} utf8Str The UTF-8 string.
      *
      * @return {WordArray} The word array.
      *
      * @static
      *
      * @example
      *
      *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
      */
    parse: function (utf8Str) {
        return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
    }
};

/**
  * Abstract buffered block algorithm template.
  *
  * The property blockSize must be implemented in a concrete subtype.
  *
  * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
  */
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({

    /**
      * Resets this block algorithm's data buffer to its initial state.
      *
      * @example
      *
      *     bufferedBlockAlgorithm.reset();
      */
    reset: function () {
        // Initial values
        this._data = new WordArray.init();    // eslint-disable-line
        this._nDataBytes = 0;
    },

    /**
      * Adds new data to this block algorithm's buffer.
      *
      * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
      *
      * @example
      *
      *     bufferedBlockAlgorithm._append('data');
      *     bufferedBlockAlgorithm._append(wordArray);
      */
    _append: function (data) {
        // Convert string to WordArray, else assume WordArray already
        if (typeof data === 'string') {
            data = Utf8.parse(data);
        }

        // Append
        this._data.concat(data);
        this._nDataBytes += data.sigBytes;
    },

    /**
      * Processes available data blocks.
      *
      * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
      *
      * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
      *
      * @return {WordArray} The processed data.
      *
      * @example
      *
      *     var processedData = bufferedBlockAlgorithm._process();
      *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
      */
    _process: function (doFlush) {
        // Shortcuts
        var data = this._data;
        var dataWords = data.words;
        var dataSigBytes = data.sigBytes;
        var blockSize = this.blockSize;
        var blockSizeBytes = blockSize * 4;

        // Count blocks ready
        var nBlocksReady = dataSigBytes / blockSizeBytes;
        if (doFlush) {
            // Round up to include partial blocks
            nBlocksReady = Math.ceil(nBlocksReady);
        }
        else {
            // Round down to include only full blocks,
            // less the number of blocks that must remain in the buffer
            nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
        }

        // Count words ready
        var nWordsReady = nBlocksReady * blockSize;

        // Count bytes ready
        var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);

        // Process blocks
        if (nWordsReady) {
            for (var offset = 0; offset < nWordsReady; offset += blockSize) {
                // Perform concrete-algorithm logic
                this._doProcessBlock(dataWords, offset);
            }

            // Remove processed words
            var processedWords = dataWords.splice(0, nWordsReady);
            data.sigBytes -= nBytesReady;
        }

        // Return processed words
        return new WordArray.init(processedWords, nBytesReady);   // eslint-disable-line
    },

    /**
      * Creates a copy of this object.
      *
      * @return {Object} The clone.
      *
      * @example
      *
      *     var clone = bufferedBlockAlgorithm.clone();
      */
    clone: function () {
        var clone = Base.clone.call(this);
        clone._data = this._data.clone();

        return clone;
    },

    _minBufferSize: 0
});

/**
  * Abstract hasher template.
  *
  * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
  */
C_lib.Hasher = BufferedBlockAlgorithm.extend({

    /**
      * Configuration options.
      */
    cfg: Base.extend(),

    /**
      * Initializes a newly created hasher.
      *
      * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
      *
      * @example
      *
      *     var hasher = CryptoJS.algo.SHA256.create();
      */
    init: function (cfg) {
        // Apply config defaults
        this.cfg = this.cfg.extend(cfg);

        // Set initial values
        this.reset();
    },

    /**
      * Resets this hasher to its initial state.
      *
      * @example
      *
      *     hasher.reset();
      */
    reset: function () {
        // Reset data buffer
        BufferedBlockAlgorithm.reset.call(this);

        // Perform concrete-hasher logic
        this._doReset();
    },

    /**
      * Updates this hasher with a message.
      *
      * @param {WordArray|string} messageUpdate The message to append.
      *
      * @return {Hasher} This hasher.
      *
      * @example
      *
      *     hasher.update('message');
      *     hasher.update(wordArray);
      */
    update: function (messageUpdate) {
        // Append
        this._append(messageUpdate);

        // Update the hash
        this._process();

        // Chainable
        return this;
    },

    /**
      * Finalizes the hash computation.
      * Note that the finalize operation is effectively a destructive, read-once operation.
      *
      * @param {WordArray|string} messageUpdate (Optional) A final message update.
      *
      * @return {WordArray} The hash.
      *
      * @example
      *
      *     var hash = hasher.finalize();
      *     var hash = hasher.finalize('message');
      *     var hash = hasher.finalize(wordArray);
      */
    finalize: function (messageUpdate) {
        // Final message update
        if (messageUpdate) {
            this._append(messageUpdate);
        }

        // Perform concrete-hasher logic
        var hash = this._doFinalize();

        return hash;
    },

    blockSize: 512 / 32,

    /**
      * Creates a shortcut function to a hasher's object interface.
      *
      * @param {Hasher} hasher The hasher to create a helper for.
      *
      * @return {Function} The shortcut function.
      *
      * @static
      *
      * @example
      *
      *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
      */
    _createHelper: function (hasher) {
        return function (message, cfg) {
            return new hasher.init(cfg).finalize(message);    // eslint-disable-line
        };
    },

    /**
      * Creates a shortcut function to the HMAC's object interface.
      *
      * @param {Hasher} hasher The hasher to use in this HMAC helper.
      *
      * @return {Function} The shortcut function.
      *
      * @static
      *
      * @example
      *
      *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
      */
    _createHmacHelper: function (hasher) {
        return function (message, key) {
            return new C_algo.HMAC.init(hasher, key).finalize(message);   // eslint-disable-line
        };
    }
});

module.exports = C;

},{}],37:[function(require,module,exports){
/**
 * @file hmac-sha256.js
 * @author ???
 */
require(39);
require(38);
var CryptoJS = require(36);

module.exports = CryptoJS.HmacSHA256;

},{"36":36,"38":38,"39":39}],38:[function(require,module,exports){
/**
 * @file hmac.js
 * @author ???
 */

var CryptoJS = require(36);

// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var C_enc = C.enc;
var Utf8 = C_enc.Utf8;
var C_algo = C.algo;

/**
 * HMAC algorithm.
 */
C_algo.HMAC = Base.extend({

    /**
     * Initializes a newly created HMAC.
     *
     * @param {Hasher} hasher The hash algorithm to use.
     * @param {WordArray|string} key The secret key.
     *
     * @example
     *
     *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
     */
    init: function (hasher, key) {
        // Init hasher
        hasher = this._hasher = new hasher.init();    // eslint-disable-line

        // Convert string to WordArray, else assume WordArray already
        if (typeof key === 'string') {
            key = Utf8.parse(key);
        }

        // Shortcuts
        var hasherBlockSize = hasher.blockSize;
        var hasherBlockSizeBytes = hasherBlockSize * 4;

        // Allow arbitrary length keys
        if (key.sigBytes > hasherBlockSizeBytes) {
            key = hasher.finalize(key);
        }

        // Clamp excess bits
        key.clamp();

        // Clone key for inner and outer pads
        var oKey = this._oKey = key.clone();
        var iKey = this._iKey = key.clone();

        // Shortcuts
        var oKeyWords = oKey.words;
        var iKeyWords = iKey.words;

        // XOR keys with pad constants
        for (var i = 0; i < hasherBlockSize; i++) {
            oKeyWords[i] ^= 0x5c5c5c5c;
            iKeyWords[i] ^= 0x36363636;
        }
        oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;

        // Set initial values
        this.reset();
    },

    /**
     * Resets this HMAC to its initial state.
     *
     * @example
     *
     *     hmacHasher.reset();
     */
    reset: function () {
        // Shortcut
        var hasher = this._hasher;

        // Reset
        hasher.reset();
        hasher.update(this._iKey);
    },

    /**
     * Updates this HMAC with a message.
     *
     * @param {WordArray|string} messageUpdate The message to append.
     *
     * @return {HMAC} This HMAC instance.
     *
     * @example
     *
     *     hmacHasher.update('message');
     *     hmacHasher.update(wordArray);
     */
    update: function (messageUpdate) {
        this._hasher.update(messageUpdate);

        // Chainable
        return this;
    },

    /**
     * Finalizes the HMAC computation.
     * Note that the finalize operation is effectively a destructive, read-once operation.
     *
     * @param {WordArray|string} messageUpdate (Optional) A final message update.
     *
     * @return {WordArray} The HMAC.
     *
     * @example
     *
     *     var hmac = hmacHasher.finalize();
     *     var hmac = hmacHasher.finalize('message');
     *     var hmac = hmacHasher.finalize(wordArray);
     */
    finalize: function (messageUpdate) {
        // Shortcut
        var hasher = this._hasher;

        // Compute HMAC
        var innerHash = hasher.finalize(messageUpdate);
        hasher.reset();
        var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));

        return hmac;
    }
});

},{"36":36}],39:[function(require,module,exports){
/**
 * @file sha256.js
 * @author ???
 */
var CryptoJS = require(36);

    // Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;

// Initialization and round constants tables
var H = [];
var K = [];

// Compute constants
(function () {
    function isPrime(n) {
        var sqrtN = Math.sqrt(n);
        for (var factor = 2; factor <= sqrtN; factor++) {
            if (!(n % factor)) {
                return false;
            }

        }

        return true;
    }

    function getFractionalBits(n) {
        return ((n - (n | 0)) * 0x100000000) | 0;
    }

    var n = 2;
    var nPrime = 0;
    while (nPrime < 64) {
        if (isPrime(n)) {
            if (nPrime < 8) {
                H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));
            }

            K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));

            nPrime++;
        }

        n++;
    }
}());

// Reusable object
var W = [];

/**
 * SHA-256 hash algorithm.
 */
var SHA256 = C_algo.SHA256 = Hasher.extend({
    _doReset: function () {
        this._hash = new WordArray.init(H.slice(0));    // eslint-disable-line
    },

    _doProcessBlock: function (M, offset) {
        // Shortcut
        var H = this._hash.words;

        // Working variables
        var a = H[0];
        var b = H[1];
        var c = H[2];
        var d = H[3];
        var e = H[4];
        var f = H[5];
        var g = H[6];
        var h = H[7];

        // Computation
        for (var i = 0; i < 64; i++) {
            if (i < 16) {
                W[i] = M[offset + i] | 0;
            }
            else {
                var gamma0x = W[i - 15];
                var gamma0 = ((gamma0x << 25)
                    | (gamma0x >>> 7)) ^ ((gamma0x << 14)
                    | (gamma0x >>> 18)) ^ (gamma0x >>> 3);

                var gamma1x = W[i - 2];
                var gamma1 = ((gamma1x << 15)
                    | (gamma1x >>> 17)) ^ ((gamma1x << 13)
                    | (gamma1x >>> 19)) ^ (gamma1x >>> 10);

                W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
            }

            var ch = (e & f) ^ (~e & g);
            var maj = (a & b) ^ (a & c) ^ (b & c);

            var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
            var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25));

            var t1 = h + sigma1 + ch + K[i] + W[i];
            var t2 = sigma0 + maj;

            h = g;
            g = f;
            f = e;
            e = (d + t1) | 0;
            d = c;
            c = b;
            b = a;
            a = (t1 + t2) | 0;
        }

        // Intermediate hash value
        H[0] = (H[0] + a) | 0;
        H[1] = (H[1] + b) | 0;
        H[2] = (H[2] + c) | 0;
        H[3] = (H[3] + d) | 0;
        H[4] = (H[4] + e) | 0;
        H[5] = (H[5] + f) | 0;
        H[6] = (H[6] + g) | 0;
        H[7] = (H[7] + h) | 0;
    },

    _doFinalize: function () {
        // Shortcuts
        var data = this._data;
        var dataWords = data.words;

        var nBitsTotal = this._nDataBytes * 8;
        var nBitsLeft = data.sigBytes * 8;

        // Add padding
        dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
        dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
        dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
        data.sigBytes = dataWords.length * 4;

        // Hash final blocks
        this._process();

        // Return final computed hash
        return this._hash;
    },

    clone: function () {
        var clone = Hasher.clone.call(this);
        clone._hash = this._hash.clone();

        return clone;
    }
});

/**
 * Shortcut function to the hasher's object interface.
 *
 * @param {WordArray|string} message The message to hash.
 *
 * @return {WordArray} The hash.
 *
 * @static
 *
 * @example
 *
 *     var hash = CryptoJS.SHA256('message');
 *     var hash = CryptoJS.SHA256(wordArray);
 */
C.SHA256 = Hasher._createHelper(SHA256);

/**
 * Shortcut function to the HMAC's object interface.
 *
 * @param {WordArray|string} message The message to hash.
 * @param {WordArray|string} key The secret key.
 *
 * @return {WordArray} The HMAC.
 *
 * @static
 *
 * @example
 *
 *     var hmac = CryptoJS.HmacSHA256(message, key);
 */
C.HmacSHA256 = Hasher._createHmacHelper(SHA256);

module.exports = CryptoJS.SHA256;

},{"36":36}],40:[function(require,module,exports){
/**
 * @file vendor/crypto.js
 * @author leeight
 */

var HmacSHA256 = require(37);
var Hex = require(36).enc.Hex;

exports.createHmac = function (type, key) {
    if (type === 'sha256') {
        var result = null;

        var sha256Hmac = {
            update: function (data) {
                /* eslint-disable */
                result = HmacSHA256(data, key).toString(Hex);
                /* eslint-enable */
            },
            digest: function () {
                return result;
            }
        };

        return sha256Hmac;
    }
};










},{"36":36,"37":37}],41:[function(require,module,exports){
/**
 * @file vendor/events.js
 * @author leeight
 */

/**
 * EventEmitter
 *
 * @class
 */
function EventEmitter() {
    this.__events = {};
}

EventEmitter.prototype.emit = function (eventName, var_args) {
    var handlers = this.__events[eventName];
    if (!handlers) {
        return false;
    }

    var args = [].slice.call(arguments, 1);
    for (var i = 0; i < handlers.length; i++) {
        var handler = handlers[i];
        try {
            handler.apply(this, args);
        }
        catch (ex) {
            // IGNORE
        }
    }

    return true;
};

EventEmitter.prototype.on = function (eventName, listener) {
    if (!this.__events[eventName]) {
        this.__events[eventName] = [listener];
    }
    else {
        this.__events[eventName].push(listener);
    }
};

exports.EventEmitter = EventEmitter;


},{}],42:[function(require,module,exports){
/**
 * @file vendor/helper.js
 * @author leeight
 */

function pad(number) {
    if (number < 10) {
        return '0' + number;
    }
    return number;
}

exports.toISOString = function (date) {
    if (date.toISOString) {
        return date.toISOString();
    }
    return date.getUTCFullYear()
        + '-' + pad(date.getUTCMonth() + 1)
        + '-' + pad(date.getUTCDate())
        + 'T' + pad(date.getUTCHours())
        + ':' + pad(date.getUTCMinutes())
        + ':' + pad(date.getUTCSeconds())
        + '.' + (date.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5)
        + 'Z';
};

exports.toUTCString = function (date) {
    var isoString = exports.toISOString(date);
    return isoString.replace(/\.\d+Z$/, 'Z');
};











},{}],43:[function(require,module,exports){
/**
 * @file vendor/path.js
 * @author leeight
 */

var u = require(46);

// Split a filename into [root, dir, basename, ext], unix version
// 'root' is just a slash, or nothing.
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;

function splitPath(filename) {
    return splitPathRe.exec(filename).slice(1);
}

// resolves . and .. elements in a path array with directory names there
// must be no slashes, empty elements, or device names (c:\) in the array
// (so also no leading and trailing slashes - it does not distinguish
// relative and absolute paths)
function normalizeArray(parts, allowAboveRoot) {
    // if the path tries to go above the root, `up` ends up > 0
    var up = 0;

    for (var i = parts.length - 1; i >= 0; i--) {
        var last = parts[i];

        if (last === '.') {
            parts.splice(i, 1);
        }
        else if (last === '..') {
            parts.splice(i, 1);
            up++;
        }
        else if (up) {
            parts.splice(i, 1);
            up--;
        }
    }

    // if the path is allowed to go above the root, restore leading ..s
    if (allowAboveRoot) {
        for (; up--; up) {
            parts.unshift('..');
        }
    }

    return parts;
}

// String.prototype.substr - negative index don't work in IE8
var substr = 'ab'.substr(-1) === 'b'
    ? function (str, start, len) {
        return str.substr(start, len);
    }
    : function (str, start, len) {
        if (start < 0) {
            start = str.length + start;
        }
        return str.substr(start, len);
    };

exports.extname = function (path) {
    return splitPath(path)[3];
};

exports.join = function () {
    var paths = Array.prototype.slice.call(arguments, 0);
    return exports.normalize(u.filter(paths, function (p, index) {
        if (typeof p !== 'string') {
            throw new TypeError('Arguments to path.join must be strings');
        }
        return p;
    }).join('/'));
};

exports.normalize = function (path) {
    var isAbsolute = path.charAt(0) === '/';
    var trailingSlash = substr(path, -1) === '/';

    // Normalize the path
    path = normalizeArray(u.filter(path.split('/'), function (p) {
        return !!p;
    }), !isAbsolute).join('/');

    if (!path && !isAbsolute) {
        path = '.';
    }
    if (path && trailingSlash) {
        path += '/';
    }

    return (isAbsolute ? '/' : '') + path;
};










},{"46":46}],44:[function(require,module,exports){
/**
 * @file src/vendor/q.js
 * @author leeight
 */
var Promise = require(34);

exports.resolve = function () {
    return Promise.resolve.apply(Promise, arguments);
};

exports.reject = function () {
    return Promise.reject.apply(Promise, arguments);
};

exports.all = function () {
    return Promise.all.apply(Promise, arguments);
};

exports.fcall = function (fn) {
    try {
        return Promise.resolve(fn());
    }
    catch (ex) {
        return Promise.reject(ex);
    }
};

exports.defer = function () {
    var deferred = {};

    deferred.promise = new Promise(function (resolve, reject) {
        deferred.resolve = function () {
            resolve.apply(null, arguments);
        };
        deferred.reject = function () {
            reject.apply(null, arguments);
        };
    });

    return deferred;
};











},{"34":34}],45:[function(require,module,exports){
/**
 * @file src/vendor/querystring.js
 * @author leeight
 */

var u = require(46);

function stringifyPrimitive(v) {
    if (typeof v === 'string') {
        return v;
    }

    if (typeof v === 'number' && isFinite(v)) {
        return '' + v;
    }

    if (typeof v === 'boolean') {
        return v ? 'true' : 'false';
    }

    return '';
}

exports.stringify = function stringify(obj, sep, eq, options) {
    sep = sep || '&';
    eq = eq || '=';

    var encode = encodeURIComponent; // QueryString.escape;
    if (options && typeof options.encodeURIComponent === 'function') {
        encode = options.encodeURIComponent;
    }

    if (obj !== null && typeof obj === 'object') {
        var keys = u.keys(obj);
        var len = keys.length;
        var flast = len - 1;
        var fields = '';
        for (var i = 0; i < len; ++i) {
            var k = keys[i];
            var v = obj[k];
            var ks = encode(stringifyPrimitive(k)) + eq;

            if (u.isArray(v)) {
                var vlen = v.length;
                var vlast = vlen - 1;
                for (var j = 0; j < vlen; ++j) {
                    fields += ks + encode(stringifyPrimitive(v[j]));
                    if (j < vlast) {
                        fields += sep;
                    }

                }
                if (vlen && i < flast) {
                    fields += sep;
                }
            }
            else {
                fields += ks + encode(stringifyPrimitive(v));
                if (i < flast) {
                    fields += sep;
                }
            }
        }
        return fields;
    }

    return '';
};

},{"46":46}],46:[function(require,module,exports){
/**
 * ag --no-filename -o '\b(u\..*?)\(' .  | sort | uniq -c
 *
 * @file vendor/underscore.js
 * @author leeight
 */

var isArray = require(5);
var noop = require(10);
var isNumber = require(13);
var isObject = require(14);

var stringTag = '[object String]';
var objectProto = Object.prototype;
var objectToString = objectProto.toString;

function isString(value) {
    return typeof value === 'string' || objectToString.call(value) === stringTag;
}

function isFunction(value) {
    return typeof value === 'function';
}

function extend(source, var_args) {
    for (var i = 1; i < arguments.length; i++) {
        var item = arguments[i];
        if (item && isObject(item)) {
            var oKeys = keys(item);
            for (var j = 0; j < oKeys.length; j++) {
                var key = oKeys[j];
                var value = item[key];
                source[key] = value;
            }
        }
    }

    return source;
}

function map(array, callback, context) {
    var result = [];
    for (var i = 0; i < array.length; i++) {
        result[i] = callback.call(context, array[i], i, array);
    }
    return result;
}

function foreach(array, callback, context) {
    for (var i = 0; i < array.length; i++) {
        callback.call(context, array[i], i, array);
    }
}

function find(array, callback, context) {
    for (var i = 0; i < array.length; i++) {
        var value = array[i];
        if (callback.call(context, value, i, array)) {
            return value;
        }
    }
}

function filter(array, callback, context) {
    var res = [];
    for (var i = 0; i < array.length; i++) {
        var value = array[i];
        if (callback.call(context, value, i, array)) {
            res.push(value);
        }
    }
    return res;
}

function indexOf(array, value) {
    for (var i = 0; i < array.length; i++) {
        if (array[i] === value) {
            return i;
        }
    }
    return -1;
}

function omit(object, var_args) {
    var args = isArray(var_args)
        ? var_args
        : [].slice.call(arguments, 1);

    var result = {};

    var oKeys = keys(object);
    for (var i = 0; i < oKeys.length; i++) {
        var key = oKeys[i];
        if (indexOf(args, key) === -1) {
            result[key] = object[key];
        }
    }

    return result;
}

function pick(object, var_args, context) {
    var result = {};

    var i;
    var key;
    var value;

    if (isFunction(var_args)) {
        var callback = var_args;
        var oKeys = keys(object);
        for (i = 0; i < oKeys.length; i++) {
            key = oKeys[i];
            value = object[key];
            if (callback.call(context, value, key, object)) {
                result[key] = value;
            }
        }
    }
    else {
        var args = isArray(var_args)
            ? var_args
            : [].slice.call(arguments, 1);

        for (i = 0; i < args.length; i++) {
            key = args[i];
            if (object.hasOwnProperty(key)) {
                result[key] = object[key];
            }
        }
    }

    return result;
}

function bind(fn, context) {
    return function () {
        return fn.apply(context, [].slice.call(arguments));
    };
}

var hasOwnProperty = Object.prototype.hasOwnProperty;
var hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString');
var dontEnums = ['toString', 'toLocaleString', 'valueOf', 'hasOwnProperty',
    'isPrototypeOf', 'propertyIsEnumerable', 'constructor'];

function keys(obj) {
    var result = [];
    var prop;
    var i;

    for (prop in obj) {
        if (hasOwnProperty.call(obj, prop)) {
            result.push(prop);
        }
    }

    if (hasDontEnumBug) {
        for (i = 0; i < dontEnums.length; i++) {
            if (hasOwnProperty.call(obj, dontEnums[i])) {
                result.push(dontEnums[i]);
            }
        }
    }

    return result;
}

exports.bind = bind;
exports.each = foreach;
exports.extend = extend;
exports.filter = filter;
exports.find = find;
exports.isArray = isArray;
exports.isFunction = isFunction;
exports.isNumber = isNumber;
exports.isObject = isObject;
exports.isString = isString;
exports.map = map;
exports.omit = omit;
exports.pick = pick;
exports.keys = keys;
exports.noop = noop;














},{"10":10,"13":13,"14":14,"5":5}],47:[function(require,module,exports){
/**
 * @file vendor/util.js
 * @author leeight
 */

var u = require(46);

exports.inherits = function (subClass, superClass) {
    var subClassProto = subClass.prototype;
    var F = new Function();
    F.prototype = superClass.prototype;
    subClass.prototype = new F();
    subClass.prototype.constructor = subClass;
    u.extend(subClass.prototype, subClassProto);
};

exports.format = function (f) {
    var argLen = arguments.length;

    if (argLen === 1) {
        return f;
    }

    var str = '';
    var a = 1;
    var lastPos = 0;
    for (var i = 0; i < f.length;) {
        if (f.charCodeAt(i) === 37 /** '%' */ && i + 1 < f.length) {
            switch (f.charCodeAt(i + 1)) {
                case 100: // 'd'
                    if (a >= argLen) {
                        break;
                    }

                    if (lastPos < i) {
                        str += f.slice(lastPos, i);
                    }

                    str += Number(arguments[a++]);
                    lastPos = i = i + 2;
                    continue;
                case 115: // 's'
                    if (a >= argLen) {
                        break;
                    }

                    if (lastPos < i) {
                        str += f.slice(lastPos, i);
                    }

                    str += String(arguments[a++]);
                    lastPos = i = i + 2;
                    continue;
                case 37: // '%'
                    if (lastPos < i) {
                        str += f.slice(lastPos, i);
                    }

                    str += '%';
                    lastPos = i = i + 2;
                    continue;
            }
        }

        ++i;
    }

    if (lastPos === 0) {
        str = f;
    }
    else if (lastPos < f.length) {
        str += f.slice(lastPos);
    }

    return str;
};

},{"46":46}]},{},[1])(1)
});
//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","index.js","node_modules/async.maplimit/index.js","node_modules/async.util.doparallellimit/index.js","node_modules/async.util.eachoflimit/index.js","node_modules/async.util.isarray/index.js","node_modules/async.util.isarraylike/index.js","node_modules/async.util.keyiterator/index.js","node_modules/async.util.keys/index.js","node_modules/async.util.mapasync/index.js","node_modules/async.util.noop/index.js","node_modules/async.util.once/index.js","node_modules/async.util.onlyonce/index.js","node_modules/lodash.isnumber/index.js","node_modules/lodash.isobject/index.js","src/bce-sdk-js/auth.js","src/bce-sdk-js/bce_base_client.js","src/bce-sdk-js/bos_client.js","src/bce-sdk-js/config.js","src/bce-sdk-js/headers.js","src/bce-sdk-js/http_client.js","src/bce-sdk-js/mime.types.js","src/bce-sdk-js/strings.js","src/config.js","src/events.js","src/multipart_task.js","src/network_info.js","src/put_object_task.js","src/queue.js","src/sts_token_manager.js","src/task.js","src/uploader.js","src/utils.js","src/vendor/Buffer.js","src/vendor/Promise.js","src/vendor/async.js","src/vendor/crypto-js/core.js","src/vendor/crypto-js/hmac-sha256.js","src/vendor/crypto-js/hmac.js","src/vendor/crypto-js/sha256.js","src/vendor/crypto.js","src/vendor/events.js","src/vendor/helper.js","src/vendor/path.js","src/vendor/q.js","src/vendor/querystring.js","src/vendor/underscore.js","src/vendor/util.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtWA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzWA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjmBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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lvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file bce-bos-uploader/index.js\n * @author leeight\n */\n\nvar Q = require(44);\nvar BosClient = require(17);\nvar Auth = require(15);\n\nvar Uploader = require(31);\nvar utils = require(32);\n\nmodule.exports = {\n    bos: {\n        Uploader: Uploader\n    },\n    utils: utils,\n    sdk: {\n        Q: Q,\n        BosClient: BosClient,\n        Auth: Auth\n    }\n};\n\n\n\n\n\n\n\n\n\n","'use strict';\nvar mapAsync = require(9);\nvar doParallelLimit = require(3);\nmodule.exports = doParallelLimit(mapAsync);\n\n\n","'use strict';\n\nvar eachOfLimit = require(4);\n\nmodule.exports = function doParallelLimit(fn) {\n    return function(obj, limit, iterator, cb) {\n        return fn(eachOfLimit(limit), obj, iterator, cb);\n    };\n};\n","var once = require(11);\nvar noop = require(10);\nvar onlyOnce = require(12);\nvar keyIterator = require(7);\n\nmodule.exports = function eachOfLimit(limit) {\n    return function(obj, iterator, cb) {\n        cb = once(cb || noop);\n        obj = obj || [];\n        var nextKey = keyIterator(obj);\n        if (limit <= 0) {\n            return cb(null);\n        }\n        var done = false;\n        var running = 0;\n        var errored = false;\n\n        (function replenish() {\n            if (done && running <= 0) {\n                return cb(null);\n            }\n\n            while (running < limit && !errored) {\n                var key = nextKey();\n                if (key === null) {\n                    done = true;\n                    if (running <= 0) {\n                        cb(null);\n                    }\n                    return;\n                }\n                running += 1;\n                iterator(obj[key], key, onlyOnce(function(err) {\n                    running -= 1;\n                    if (err) {\n                        cb(err);\n                        errored = true;\n                    } else {\n                        replenish();\n                    }\n                }));\n            }\n        })();\n    };\n};\n","'use strict';\n\nmodule.exports = Array.isArray || function isArray(obj) {\n    return Object.prototype.toString.call(obj) === '[object Array]';\n};\n","'use strict';\n\nvar isArray = require(5);\n\nmodule.exports = function isArrayLike(arr) {\n    return isArray(arr) || (\n        // has a positive integer length property\n        typeof arr.length === 'number' &&\n        arr.length >= 0 &&\n        arr.length % 1 === 0\n    );\n};\n","'use strict';\n\nvar _keys = require(8);\nvar isArrayLike = require(6);\n\nmodule.exports = function keyIterator(coll) {\n    var i = -1;\n    var len;\n    var keys;\n    if (isArrayLike(coll)) {\n        len = coll.length;\n        return function next() {\n            i++;\n            return i < len ? i : null;\n        };\n    } else {\n        keys = _keys(coll);\n        len = keys.length;\n        return function next() {\n            i++;\n            return i < len ? keys[i] : null;\n        };\n    }\n};\n","'use strict';\n\nmodule.exports = Object.keys || function keys(obj) {\n    var _keys = [];\n    for (var k in obj) {\n        if (obj.hasOwnProperty(k)) {\n            _keys.push(k);\n        }\n    }\n    return _keys;\n};\n","'use strict';\n\nvar once = require(11);\nvar noop = require(10);\nvar isArrayLike = require(6);\n\nmodule.exports = function mapAsync(eachfn, arr, iterator, cb) {\n    cb = once(cb || noop);\n    arr = arr || [];\n    var results = isArrayLike(arr) ? [] : {};\n    eachfn(arr, function (value, index, cb) {\n        iterator(value, function (err, v) {\n            results[index] = v;\n            cb(err);\n        });\n    }, function (err) {\n        cb(err, results);\n    });\n};\n","'use strict';\n\nmodule.exports = function noop () {};\n","'use strict';\n\nmodule.exports = function once(fn) {\n    return function() {\n        if (fn === null) return;\n        fn.apply(this, arguments);\n        fn = null;\n    };\n};\n","'use strict';\n\nmodule.exports = function only_once(fn) {\n    return function() {\n        if (fn === null) throw new Error('Callback was already called.');\n        fn.apply(this, arguments);\n        fn = null;\n    };\n};\n","/**\n * lodash 3.0.3 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\n */\n\n/** `Object#toString` result references. */\nvar numberTag = '[object Number]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Number` primitive or object.\n *\n * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified\n * as numbers, use the `_.isFinite` method.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isNumber(3);\n * // => true\n *\n * _.isNumber(Number.MIN_VALUE);\n * // => true\n *\n * _.isNumber(Infinity);\n * // => true\n *\n * _.isNumber('3');\n * // => false\n */\nfunction isNumber(value) {\n  return typeof value == 'number' ||\n    (isObjectLike(value) && objectToString.call(value) == numberTag);\n}\n\nmodule.exports = isNumber;\n","/**\n * lodash 3.0.2 (Custom Build) <https://lodash.com/>\n * Build: `lodash modern modularize exports=\"npm\" -o ./`\n * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\n */\n\n/**\n * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(1);\n * // => false\n */\nfunction isObject(value) {\n  // Avoid a V8 JIT bug in Chrome 19-20.\n  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file src/auth.js\n * @author leeight\n */\n\n/* eslint-env node */\n/* eslint max-params:[0,10] */\n\nvar helper = require(42);\nvar util = require(47);\nvar u = require(46);\nvar H = require(19);\nvar strings = require(22);\n\n/**\n * Auth\n *\n * @constructor\n * @param {string} ak The access key.\n * @param {string} sk The security key.\n */\nfunction Auth(ak, sk) {\n    this.ak = ak;\n    this.sk = sk;\n}\n\n/**\n * Generate the signature based on http://gollum.baidu.com/AuthenticationMechanism\n *\n * @param {string} method The http request method, such as GET, POST, DELETE, PUT, ...\n * @param {string} resource The request path.\n * @param {Object=} params The query strings.\n * @param {Object=} headers The http request headers.\n * @param {number=} timestamp Set the current timestamp.\n * @param {number=} expirationInSeconds The signature validation time.\n * @param {Array.<string>=} headersToSign The request headers list which will be used to calcualate the signature.\n *\n * @return {string} The signature.\n */\nAuth.prototype.generateAuthorization = function (method, resource, params,\n                                                 headers, timestamp, expirationInSeconds, headersToSign) {\n\n    var now = timestamp ? new Date(timestamp * 1000) : new Date();\n    var rawSessionKey = util.format('bce-auth-v1/%s/%s/%d',\n        this.ak, helper.toUTCString(now), expirationInSeconds || 1800);\n    var sessionKey = this.hash(rawSessionKey, this.sk);\n\n    var canonicalUri = this.uriCanonicalization(resource);\n    var canonicalQueryString = this.queryStringCanonicalization(params || {});\n\n    var rv = this.headersCanonicalization(headers || {}, headersToSign);\n    var canonicalHeaders = rv[0];\n    var signedHeaders = rv[1];\n\n    var rawSignature = util.format('%s\\n%s\\n%s\\n%s',\n        method, canonicalUri, canonicalQueryString, canonicalHeaders);\n    var signature = this.hash(rawSignature, sessionKey);\n\n    if (signedHeaders.length) {\n        return util.format('%s/%s/%s', rawSessionKey, signedHeaders.join(';'), signature);\n    }\n\n    return util.format('%s//%s', rawSessionKey, signature);\n};\n\nAuth.prototype.uriCanonicalization = function (uri) {\n    return uri;\n};\n\n/**\n * Canonical the query strings.\n *\n * @see http://gollum.baidu.com/AuthenticationMechanism#生成CanonicalQueryString\n * @param {Object} params The query strings.\n * @return {string}\n */\nAuth.prototype.queryStringCanonicalization = function (params) {\n    var canonicalQueryString = [];\n    u.each(u.keys(params), function (key) {\n        if (key.toLowerCase() === H.AUTHORIZATION.toLowerCase()) {\n            return;\n        }\n\n        var value = params[key] == null ? '' : params[key];\n        canonicalQueryString.push(key + '=' + strings.normalize(value));\n    });\n\n    canonicalQueryString.sort();\n\n    return canonicalQueryString.join('&');\n};\n\n/**\n * Canonical the http request headers.\n *\n * @see http://gollum.baidu.com/AuthenticationMechanism#生成CanonicalHeaders\n * @param {Object} headers The http request headers.\n * @param {Array.<string>=} headersToSign The request headers list which will be used to calcualate the signature.\n * @return {*} canonicalHeaders and signedHeaders\n */\nAuth.prototype.headersCanonicalization = function (headers, headersToSign) {\n    if (!headersToSign || !headersToSign.length) {\n        headersToSign = [H.HOST, H.CONTENT_MD5, H.CONTENT_LENGTH, H.CONTENT_TYPE];\n    }\n\n    var headersMap = {};\n    u.each(headersToSign, function (item) {\n        headersMap[item.toLowerCase()] = true;\n    });\n\n    var canonicalHeaders = [];\n    u.each(u.keys(headers), function (key) {\n        var value = headers[key];\n        value = u.isString(value) ? strings.trim(value) : value;\n        if (value == null || value === '') {\n            return;\n        }\n        key = key.toLowerCase();\n        if (/^x\\-bce\\-/.test(key) || headersMap[key] === true) {\n            canonicalHeaders.push(util.format('%s:%s',\n                // encodeURIComponent(key), encodeURIComponent(value)));\n                strings.normalize(key), strings.normalize(value)));\n        }\n    });\n\n    canonicalHeaders.sort();\n\n    var signedHeaders = [];\n    u.each(canonicalHeaders, function (item) {\n        signedHeaders.push(item.split(':')[0]);\n    });\n\n    return [canonicalHeaders.join('\\n'), signedHeaders];\n};\n\nAuth.prototype.hash = function (data, key) {\n    var crypto = require(40);\n    var sha256Hmac = crypto.createHmac('sha256', key);\n    sha256Hmac.update(data);\n    return sha256Hmac.digest('hex');\n};\n\nmodule.exports = Auth;\n\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file src/bce_base_client.js\n * @author leeight\n */\n\n/* eslint-env node */\n\nvar EventEmitter = require(41).EventEmitter;\nvar util = require(47);\nvar Q = require(44);\nvar u = require(46);\nvar config = require(18);\nvar Auth = require(15);\n\n/**\n * BceBaseClient\n *\n * @constructor\n * @param {Object} clientConfig The bce client configuration.\n * @param {string} serviceId The service id.\n * @param {boolean=} regionSupported The service supported region or not.\n */\nfunction BceBaseClient(clientConfig, serviceId, regionSupported) {\n    EventEmitter.call(this);\n\n    this.config = u.extend({}, config.DEFAULT_CONFIG, clientConfig);\n    this.serviceId = serviceId;\n    this.regionSupported = !!regionSupported;\n\n    this.config.endpoint = this._computeEndpoint();\n\n    /**\n     * @type {HttpClient}\n     */\n    this._httpAgent = null;\n}\nutil.inherits(BceBaseClient, EventEmitter);\n\nBceBaseClient.prototype._computeEndpoint = function () {\n    if (this.config.endpoint) {\n        return this.config.endpoint;\n    }\n\n    if (this.regionSupported) {\n        return util.format('%s://%s.%s.%s',\n            this.config.protocol,\n            this.serviceId,\n            this.config.region,\n            config.DEFAULT_SERVICE_DOMAIN);\n    }\n    return util.format('%s://%s.%s',\n        this.config.protocol,\n        this.serviceId,\n        config.DEFAULT_SERVICE_DOMAIN);\n};\n\nBceBaseClient.prototype.createSignature = function (credentials, httpMethod, path, params, headers) {\n    return Q.fcall(function () {\n        var auth = new Auth(credentials.ak, credentials.sk);\n        return auth.generateAuthorization(httpMethod, path, params, headers);\n    });\n};\n\nmodule.exports = BceBaseClient;\n\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file src/bos_client.js\n * @author leeight\n */\n\n/* eslint-env node */\n/* eslint max-params:[0,10] */\n\nvar path = require(43);\nvar util = require(47);\nvar u = require(46);\nvar Buffer = require(33);\nvar H = require(19);\nvar strings = require(22);\nvar HttpClient = require(20);\nvar BceBaseClient = require(16);\nvar MimeType = require(21);\n\nvar MAX_PUT_OBJECT_LENGTH = 5368709120;     // 5G\nvar MAX_USER_METADATA_SIZE = 2048;          // 2 * 1024\n\n/**\n * BOS service api\n *\n * @see http://gollum.baidu.com/BOS_API#BOS-API文档\n *\n * @constructor\n * @param {Object} config The bos client configuration.\n * @extends {BceBaseClient}\n */\nfunction BosClient(config) {\n    BceBaseClient.call(this, config, 'bos', true);\n\n    /**\n     * @type {HttpClient}\n     */\n    this._httpAgent = null;\n}\nutil.inherits(BosClient, BceBaseClient);\n\n// --- B E G I N ---\nBosClient.prototype.deleteObject = function (bucketName, key, options) {\n    options = options || {};\n\n    return this.sendRequest('DELETE', {\n        bucketName: bucketName,\n        key: key,\n        config: options.config\n    });\n};\n\nBosClient.prototype.putObject = function (bucketName, key, data, options) {\n    if (!key) {\n        throw new TypeError('key should not be empty.');\n    }\n\n    options = this._checkOptions(options || {});\n\n    return this.sendRequest('PUT', {\n        bucketName: bucketName,\n        key: key,\n        body: data,\n        headers: options.headers,\n        config: options.config\n    });\n};\n\nBosClient.prototype.putObjectFromBlob = function (bucketName, key, blob, options) {\n    var headers = {};\n\n    // https://developer.mozilla.org/en-US/docs/Web/API/Blob/size\n    headers[H.CONTENT_LENGTH] = blob.size;\n    // 对于浏览器调用API的时候，默认不添加 H.CONTENT_MD5 字段，因为计算起来比较慢\n    // 而且根据 API 文档，这个字段不是必填的。\n    options = u.extend(headers, options);\n\n    return this.putObject(bucketName, key, blob, options);\n};\n\nBosClient.prototype.getObjectMetadata = function (bucketName, key, options) {\n    options = options || {};\n\n    return this.sendRequest('HEAD', {\n        bucketName: bucketName,\n        key: key,\n        config: options.config\n    });\n};\n\nBosClient.prototype.initiateMultipartUpload = function (bucketName, key, options) {\n    options = options || {};\n\n    var headers = {};\n    headers[H.CONTENT_TYPE] = options[H.CONTENT_TYPE] || MimeType.guess(path.extname(key));\n    return this.sendRequest('POST', {\n        bucketName: bucketName,\n        key: key,\n        params: {uploads: ''},\n        headers: headers,\n        config: options.config\n    });\n};\n\nBosClient.prototype.abortMultipartUpload = function (bucketName, key, uploadId, options) {\n    options = options || {};\n\n    return this.sendRequest('DELETE', {\n        bucketName: bucketName,\n        key: key,\n        params: {uploadId: uploadId},\n        config: options.config\n    });\n};\n\nBosClient.prototype.completeMultipartUpload = function (bucketName, key, uploadId, partList, options) {\n    var headers = {};\n    headers[H.CONTENT_TYPE] = 'application/json; charset=UTF-8';\n    options = this._checkOptions(u.extend(headers, options));\n\n    return this.sendRequest('POST', {\n        bucketName: bucketName,\n        key: key,\n        body: JSON.stringify({parts: partList}),\n        headers: options.headers,\n        params: {uploadId: uploadId},\n        config: options.config\n    });\n};\n\nBosClient.prototype.uploadPartFromBlob = function (bucketName, key, uploadId, partNumber,\n                                                   partSize, blob, options) {\n    if (blob.size !== partSize) {\n        throw new TypeError(util.format('Invalid partSize %d and data length %d',\n            partSize, blob.size));\n    }\n\n    var headers = {};\n    headers[H.CONTENT_LENGTH] = partSize;\n    headers[H.CONTENT_TYPE] = 'application/octet-stream';\n\n    options = this._checkOptions(u.extend(headers, options));\n    return this.sendRequest('PUT', {\n        bucketName: bucketName,\n        key: key,\n        body: blob,\n        headers: options.headers,\n        params: {\n            partNumber: partNumber,\n            uploadId: uploadId\n        },\n        config: options.config\n    });\n};\n\nBosClient.prototype.listParts = function (bucketName, key, uploadId, options) {\n    /*eslint-disable*/\n    if (!uploadId) {\n        throw new TypeError('uploadId should not empty');\n    }\n    /*eslint-enable*/\n\n    var allowedParams = ['maxParts', 'partNumberMarker', 'uploadId'];\n    options = this._checkOptions(options || {}, allowedParams);\n    options.params.uploadId = uploadId;\n\n    return this.sendRequest('GET', {\n        bucketName: bucketName,\n        key: key,\n        params: options.params,\n        config: options.config\n    });\n};\n\nBosClient.prototype.listMultipartUploads = function (bucketName, options) {\n    var allowedParams = ['delimiter', 'maxUploads', 'keyMarker', 'prefix', 'uploads'];\n\n    options = this._checkOptions(options || {}, allowedParams);\n    options.params.uploads = '';\n\n    return this.sendRequest('GET', {\n        bucketName: bucketName,\n        params: options.params,\n        config: options.config\n    });\n};\n\nBosClient.prototype.appendObject = function (bucketName, key, data, offset, options) {\n    if (!key) {\n        throw new TypeError('key should not be empty.');\n    }\n\n    options = this._checkOptions(options || {});\n    var params = {append: ''};\n    if (u.isNumber(offset)) {\n        params.offset = offset;\n    }\n    return this.sendRequest('POST', {\n        bucketName: bucketName,\n        key: key,\n        body: data,\n        headers: options.headers,\n        params: params,\n        config: options.config\n    });\n};\n\nBosClient.prototype.appendObjectFromBlob = function (bucketName, key, blob, offset, options) {\n    var headers = {};\n\n    // https://developer.mozilla.org/en-US/docs/Web/API/Blob/size\n    headers[H.CONTENT_LENGTH] = blob.size;\n    // 对于浏览器调用API的时候，默认不添加 H.CONTENT_MD5 字段，因为计算起来比较慢\n    // 而且根据 API 文档，这个字段不是必填的。\n    options = u.extend(headers, options);\n\n    return this.appendObject(bucketName, key, blob, offset, options);\n};\n\n// --- E N D ---\n\nBosClient.prototype.sendRequest = function (httpMethod, varArgs) {\n    var defaultArgs = {\n        bucketName: null,\n        key: null,\n        body: null,\n        headers: {},\n        params: {},\n        config: {},\n        outputStream: null\n    };\n    var args = u.extend(defaultArgs, varArgs);\n\n    var config = u.extend({}, this.config, args.config);\n    var resource = [\n        '/v1',\n        strings.normalize(args.bucketName || ''),\n        strings.normalize(args.key || '', false)\n    ].join('/');\n\n    if (config.sessionToken) {\n        args.headers[H.SESSION_TOKEN] = config.sessionToken;\n    }\n\n    return this.sendHTTPRequest(httpMethod, resource, args, config);\n};\n\nBosClient.prototype.sendHTTPRequest = function (httpMethod, resource, args, config) {\n    var client = this;\n    var agent = this._httpAgent = new HttpClient(config);\n\n    var httpContext = {\n        httpMethod: httpMethod,\n        resource: resource,\n        args: args,\n        config: config\n    };\n    u.each(['progress', 'error', 'abort'], function (eventName) {\n        agent.on(eventName, function (evt) {\n            client.emit(eventName, evt, httpContext);\n        });\n    });\n\n    var promise = this._httpAgent.sendRequest(httpMethod, resource, args.body,\n        args.headers, args.params, u.bind(this.createSignature, this),\n        args.outputStream\n    );\n\n    promise.abort = function () {\n        if (agent._req && agent._req.xhr) {\n            var xhr = agent._req.xhr;\n            xhr.abort();\n        }\n    };\n\n    return promise;\n};\n\nBosClient.prototype._checkOptions = function (options, allowedParams) {\n    var rv = {};\n\n    rv.config = options.config || {};\n    rv.headers = this._prepareObjectHeaders(options);\n    rv.params = u.pick(options, allowedParams || []);\n\n    return rv;\n};\n\nBosClient.prototype._prepareObjectHeaders = function (options) {\n    var allowedHeaders = {};\n    u.each([\n        H.CONTENT_LENGTH,\n        H.CONTENT_ENCODING,\n        H.CONTENT_MD5,\n        H.X_BCE_CONTENT_SHA256,\n        H.CONTENT_TYPE,\n        H.CONTENT_DISPOSITION,\n        H.ETAG,\n        H.SESSION_TOKEN,\n        H.CACHE_CONTROL,\n        H.EXPIRES,\n        H.X_BCE_OBJECT_ACL,\n        H.X_BCE_OBJECT_GRANT_READ\n    ], function (header) {\n        allowedHeaders[header] = true;\n    });\n\n    var metaSize = 0;\n    var headers = u.pick(options, function (value, key) {\n        if (allowedHeaders[key]) {\n            return true;\n        }\n        else if (/^x\\-bce\\-meta\\-/.test(key)) {\n            metaSize += Buffer.byteLength(key) + Buffer.byteLength('' + value);\n            return true;\n        }\n    });\n\n    if (metaSize > MAX_USER_METADATA_SIZE) {\n        throw new TypeError('Metadata size should not be greater than ' + MAX_USER_METADATA_SIZE + '.');\n    }\n\n    if (headers.hasOwnProperty(H.CONTENT_LENGTH)) {\n        var contentLength = headers[H.CONTENT_LENGTH];\n        if (contentLength < 0) {\n            throw new TypeError('content_length should not be negative.');\n        }\n        else if (contentLength > MAX_PUT_OBJECT_LENGTH) { // 5G\n            throw new TypeError('Object length should be less than ' + MAX_PUT_OBJECT_LENGTH\n                + '. Use multi-part upload instead.');\n        }\n    }\n\n    if (headers.hasOwnProperty('ETag')) {\n        var etag = headers.ETag;\n        if (!/^\"/.test(etag)) {\n            headers.ETag = util.format('\"%s\"', etag);\n        }\n    }\n\n    if (!headers.hasOwnProperty(H.CONTENT_TYPE)) {\n        headers[H.CONTENT_TYPE] = 'application/octet-stream';\n    }\n\n    return headers;\n};\n\nmodule.exports = BosClient;\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file src/config.js\n * @author leeight\n */\n\n/* eslint-env node */\n\nexports.DEFAULT_SERVICE_DOMAIN = 'baidubce.com';\n\nexports.DEFAULT_CONFIG = {\n    protocol: 'http',\n    region: 'bj'\n};\n\n\n\n\n\n\n\n\n\n\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file src/headers.js\n * @author leeight\n */\n\n/* eslint-env node */\n\nexports.CONTENT_TYPE = 'Content-Type';\nexports.CONTENT_LENGTH = 'Content-Length';\nexports.CONTENT_MD5 = 'Content-MD5';\nexports.CONTENT_ENCODING = 'Content-Encoding';\nexports.CONTENT_DISPOSITION = 'Content-Disposition';\nexports.ETAG = 'ETag';\nexports.CONNECTION = 'Connection';\nexports.HOST = 'Host';\nexports.USER_AGENT = 'User-Agent';\nexports.CACHE_CONTROL = 'Cache-Control';\nexports.EXPIRES = 'Expires';\n\nexports.AUTHORIZATION = 'Authorization';\nexports.X_BCE_DATE = 'x-bce-date';\nexports.X_BCE_ACL = 'x-bce-acl';\nexports.X_BCE_REQUEST_ID = 'x-bce-request-id';\nexports.X_BCE_CONTENT_SHA256 = 'x-bce-content-sha256';\nexports.X_BCE_OBJECT_ACL = 'x-bce-object-acl';\nexports.X_BCE_OBJECT_GRANT_READ = 'x-bce-object-grant-read';\n\nexports.X_HTTP_HEADERS = 'http_headers';\nexports.X_BODY = 'body';\nexports.X_STATUS_CODE = 'status_code';\nexports.X_MESSAGE = 'message';\nexports.X_CODE = 'code';\nexports.X_REQUEST_ID = 'request_id';\n\nexports.SESSION_TOKEN = 'x-bce-security-token';\n\nexports.X_VOD_MEDIA_TITLE = 'x-vod-media-title';\nexports.X_VOD_MEDIA_DESCRIPTION = 'x-vod-media-description';\nexports.ACCEPT_ENCODING = 'accept-encoding';\nexports.ACCEPT = 'accept';\n\n\n\n\n\n\n\n\n\n\n\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file src/http_client.js\n * @author leeight\n */\n\n/* eslint-env node */\n/* eslint max-params:[0,10] */\n/* globals ArrayBuffer */\n\nvar EventEmitter = require(41).EventEmitter;\nvar Buffer = require(33);\nvar Q = require(44);\nvar helper = require(42);\nvar u = require(46);\nvar util = require(47);\nvar H = require(19);\n\n/**\n * The HttpClient\n *\n * @constructor\n * @param {Object} config The http client configuration.\n */\nfunction HttpClient(config) {\n    EventEmitter.call(this);\n\n    this.config = config;\n\n    /**\n     * http(s) request object\n     * @type {Object}\n     */\n    this._req = null;\n}\nutil.inherits(HttpClient, EventEmitter);\n\n/**\n * Send Http Request\n *\n * @param {string} httpMethod GET,POST,PUT,DELETE,HEAD\n * @param {string} path The http request path.\n * @param {(string|Buffer|stream.Readable)=} body The request body. If `body` is a\n * stream, `Content-Length` must be set explicitly.\n * @param {Object=} headers The http request headers.\n * @param {Object=} params The querystrings in url.\n * @param {function():string=} signFunction The `Authorization` signature function\n * @param {stream.Writable=} outputStream The http response body.\n * @param {number=} retry The maximum number of network connection attempts.\n *\n * @resolve {{http_headers:Object,body:Object}}\n * @reject {Object}\n *\n * @return {Q.defer}\n */\nHttpClient.prototype.sendRequest = function (httpMethod, path, body, headers, params,\n                                             signFunction, outputStream) {\n\n    var requestUrl = this._getRequestUrl(path, params);\n\n    var defaultHeaders = {};\n    defaultHeaders[H.X_BCE_DATE] = helper.toUTCString(new Date());\n    defaultHeaders[H.CONTENT_TYPE] = 'application/json; charset=UTF-8';\n    defaultHeaders[H.HOST] = /^\\w+:\\/\\/([^\\/]+)/.exec(this.config.endpoint)[1];\n\n    var requestHeaders = u.extend(defaultHeaders, headers);\n\n    // Check the content-length\n    if (!requestHeaders.hasOwnProperty(H.CONTENT_LENGTH)) {\n        var contentLength = this._guessContentLength(body);\n        if (!(contentLength === 0 && /GET|HEAD/i.test(httpMethod))) {\n            // 如果是 GET 或 HEAD 请求，并且 Content-Length 是 0，那么 Request Header 里面就不要出现 Content-Length\n            // 否则本地计算签名的时候会计算进去，但是浏览器发请求的时候不一定会有，此时导致 Signature Mismatch 的情况\n            requestHeaders[H.CONTENT_LENGTH] = contentLength;\n        }\n    }\n\n    var self = this;\n    var createSignature = signFunction || u.noop;\n    try {\n        return Q.resolve(createSignature(this.config.credentials, httpMethod, path, params, requestHeaders))\n            .then(function (authorization, xbceDate) {\n                if (authorization) {\n                    requestHeaders[H.AUTHORIZATION] = authorization;\n                }\n\n                if (xbceDate) {\n                    requestHeaders[H.X_BCE_DATE] = xbceDate;\n                }\n\n                return self._doRequest(httpMethod, requestUrl,\n                    u.omit(requestHeaders, H.CONTENT_LENGTH, H.HOST),\n                    body, outputStream);\n            });\n    }\n    catch (ex) {\n        return Q.reject(ex);\n    }\n};\n\nHttpClient.prototype._doRequest = function (httpMethod, requestUrl, requestHeaders, body, outputStream) {\n    var deferred = Q.defer();\n\n    var self = this;\n    var xhr = new XMLHttpRequest();\n    xhr.open(httpMethod, requestUrl, true);\n    for (var header in requestHeaders) {\n        if (requestHeaders.hasOwnProperty(header)) {\n            var value = requestHeaders[header];\n            xhr.setRequestHeader(header, value);\n        }\n    }\n    xhr.onerror = function (error) {\n        deferred.reject(error);\n    };\n    xhr.onabort = function () {\n        deferred.reject(new Error('xhr aborted'));\n    };\n    xhr.onreadystatechange = function () {\n        if (xhr.readyState === 4) {\n            var status = xhr.status;\n            if (status === 1223) {\n                // IE - #1450: sometimes returns 1223 when it should be 204\n                status = 204;\n            }\n\n            var contentType = xhr.getResponseHeader('Content-Type');\n            var isJSON = /application\\/json/.test(contentType);\n            var responseBody = isJSON ? JSON.parse(xhr.responseText) : xhr.responseText;\n            if (!responseBody) {\n                responseBody = {\n                    location: requestUrl\n                };\n            }\n\n            var isSuccess = status >= 200 && status < 300 || status === 304;\n            if (isSuccess) {\n                var headers = self._fixHeaders(xhr.getAllResponseHeaders());\n                deferred.resolve({\n                    http_headers: headers,\n                    body: responseBody\n                });\n            }\n            else {\n                deferred.reject({\n                    status_code: status,\n                    message: responseBody.message || '<message>',\n                    code: responseBody.code || '<code>',\n                    request_id: responseBody.requestId || '<request_id>'\n                });\n            }\n        }\n    };\n    if (xhr.upload) {\n        u.each(['progress', 'error', 'abort'], function (eventName) {\n            xhr.upload.addEventListener(eventName, function (evt) {\n                if (typeof self.emit === 'function') {\n                    self.emit(eventName, evt);\n                }\n            }, false);\n        });\n    }\n    xhr.send(body);\n\n    self._req = {xhr: xhr};\n\n    return deferred.promise;\n};\n\nHttpClient.prototype._guessContentLength = function (data) {\n    if (data == null || data === '') {\n        return 0;\n    }\n    else if (u.isString(data)) {\n        return Buffer.byteLength(data);\n    }\n    else if (typeof Blob !== 'undefined' && data instanceof Blob) {\n        return data.size;\n    }\n    else if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer) {\n        return data.byteLength;\n    }\n\n    throw new Error('No Content-Length is specified.');\n};\n\nHttpClient.prototype._fixHeaders = function (headers) {\n    var fixedHeaders = {};\n\n    if (headers) {\n        u.each(headers.split(/\\r?\\n/), function (line) {\n            var idx = line.indexOf(':');\n            if (idx !== -1) {\n                var key = line.substring(0, idx).toLowerCase();\n                var value = line.substring(idx + 1).replace(/^\\s+|\\s+$/, '');\n                if (key === 'etag') {\n                    value = value.replace(/\"/g, '');\n                }\n                fixedHeaders[key] = value;\n            }\n        });\n    }\n\n    return fixedHeaders;\n};\n\nHttpClient.prototype.buildQueryString = function (params) {\n    var urlEncodeStr = require(45).stringify(params);\n    // https://en.wikipedia.org/wiki/Percent-encoding\n    return urlEncodeStr.replace(/[()'!~.*\\-_]/g, function (char) {\n        return '%' + char.charCodeAt().toString(16);\n    });\n};\n\nHttpClient.prototype._getRequestUrl = function (path, params) {\n    var uri = path;\n    var qs = this.buildQueryString(params);\n    if (qs) {\n        uri += '?' + qs;\n    }\n\n    return this.config.endpoint + uri;\n};\n\nmodule.exports = HttpClient;\n\n","/**\n * @file src/mime.types.js\n * @author leeight\n */\n\n/* eslint-env node */\n\nvar mimeTypes = {\n};\n\nexports.guess = function (ext) {\n    if (!ext || !ext.length) {\n        return 'application/octet-stream';\n    }\n    if (ext[0] === '.') {\n        ext = ext.substr(1);\n    }\n    return mimeTypes[ext.toLowerCase()] || 'application/octet-stream';\n};\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file strings.js\n * @author leeight\n */\n\nvar kEscapedMap = {\n    '!': '%21',\n    '\\'': '%27',\n    '(': '%28',\n    ')': '%29',\n    '*': '%2A'\n};\n\nexports.normalize = function (string, encodingSlash) {\n    var result = encodeURIComponent(string);\n    result = result.replace(/[!'\\(\\)\\*]/g, function ($1) {\n        return kEscapedMap[$1];\n    });\n\n    if (encodingSlash === false) {\n        result = result.replace(/%2F/gi, '/');\n    }\n\n    return result;\n};\n\nexports.trim = function (string) {\n    return (string || '').replace(/^\\s+|\\s+$/g, '');\n};\n\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file config.js\n * @author leeight\n */\n\n\nvar kDefaultOptions = {\n    runtimes: 'html5',\n\n    // bos服务器的地址，默认(http://bj.bcebos.com)\n    // 这里不应该是 https://bj.bcebos.com，否则 Moxie.swf 可能有问题，原因未知\n    bos_endpoint: 'http://bj.bcebos.com',\n\n    // 默认的 ak 和 sk 配置\n    bos_ak: null,\n    bos_sk: null,\n    bos_credentials: null,\n\n    // 如果切换到 appendable 模式，最大只支持 5G 的文件\n    // 不再支持 Multipart 的方式上传文件\n    bos_appendable: false,\n\n    // 为了处理 Flash 不能发送 HEAD, DELETE 之类的请求，以及无法\n    // 获取 response headers 的问题，需要搞一个 relay 服务器，把数据\n    // 格式转化一下\n    bos_relay_server: 'https://relay.efe.tech',\n\n    // 是否支持多选，默认(false)\n    multi_selection: false,\n\n    // 失败之后重试的次数(单个文件或者分片)，默认(0)，不重试\n    max_retries: 0,\n\n    // 失败重试的间隔时间，默认 1000ms\n    retry_interval: 1000,\n\n    // 是否自动上传，默认(false)\n    auto_start: false,\n\n    // 最大可以选择的文件大小，默认(100M)\n    max_file_size: '100mb',\n\n    // 超过这个文件大小之后，开始使用分片上传，默认(10M)\n    bos_multipart_min_size: '10mb',\n\n    // 分片上传的时候，并行上传的个数，默认(1)\n    bos_multipart_parallel: 1,\n\n    // 队列中的文件，并行上传的个数，默认(3)\n    bos_task_parallel: 3,\n\n    // 计算签名的时候，有些 header 需要剔除，减少传输的体积\n    auth_stripped_headers: ['User-Agent', 'Connection'],\n\n    // 分片上传的时候，每个分片的大小，默认(4M)\n    chunk_size: '4mb',\n\n    // 分块上传时,是否允许断点续传，默认(false)\n    bos_multipart_auto_continue: false,\n\n    // 分开上传的时候，localStorage里面key的生成方式，默认是 `default`\n    // 如果需要自定义，可以通过 XXX\n    bos_multipart_local_key_generator: 'default',\n\n    // 是否允许选择目录\n    dir_selection: false,\n\n    // 是否需要每次都去服务器计算签名\n    get_new_uptoken: true,\n\n    // 因为使用 Form Post 的格式，没有设置额外的 Header，从而可以保证\n    // 使用 Flash 也能上传大文件\n    // 低版本浏览器上传文件的时候，需要设置 policy，默认情况下\n    // policy的内容只需要包含 expiration 和 conditions 即可\n    // policy: {\n    //   expiration: 'xx',\n    //   conditions: [\n    //     {bucket: 'the-bucket-name'}\n    //   ]\n    // }\n    // bos_policy: null,\n\n    // 低版本浏览器上传文件的时候，需要设置 policy_signature\n    // 如果没有设置 bos_policy_signature 的话，会通过 uptoken_url 来请求\n    // 默认只会请求一次，如果失效了，需要手动来重置 policy_signature\n    // bos_policy_signature: null,\n\n    // JSONP 默认的超时时间(5000ms)\n    uptoken_via_jsonp: true,\n    uptoken_timeout: 5000,\n    uptoken_jsonp_timeout: 5000,    // 不支持了，后续建议用 uptoken_timeout\n\n    // 是否要禁用统计，默认不禁用\n    // 如果需要禁用，把 tracker_id 设置成 null 即可\n    tracker_id: null\n};\n\nmodule.exports = kDefaultOptions;\n\n\n\n\n\n\n\n\n\n\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"), you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file events.js\n * @author leeight\n */\n\nmodule.exports = {\n    kPostInit: 'PostInit',\n    kKey: 'Key',\n    kListParts: 'ListParts',\n    kObjectMetas: 'ObjectMetas',\n    // kFilesRemoved  : 'FilesRemoved',\n    kFileFiltered: 'FileFiltered',\n    kFilesAdded: 'FilesAdded',\n    kFilesFilter: 'FilesFilter',\n    kNetworkSpeed: 'NetworkSpeed',\n    kBeforeUpload: 'BeforeUpload',\n    // kUploadFile    : 'UploadFile',       // ??\n    kUploadProgress: 'UploadProgress',\n    kFileUploaded: 'FileUploaded',\n    kUploadPartProgress: 'UploadPartProgress',\n    kChunkUploaded: 'ChunkUploaded',\n    kUploadResume: 'UploadResume', // 断点续传\n    // kUploadPause: 'UploadPause',   // 暂停\n    kUploadResumeError: 'UploadResumeError', // 尝试断点续传失败\n    kUploadComplete: 'UploadComplete',\n    kError: 'Error',\n    kAborted: 'Aborted'\n};\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file multipart_task.js\n * @author leeight\n */\n\nvar Q = require(44);\nvar async = require(35);\nvar u = require(46);\nvar utils = require(32);\nvar events = require(24);\nvar Task = require(30);\n\n/**\n * MultipartTask\n *\n * @class\n */\nfunction MultipartTask() {\n    Task.apply(this, arguments);\n\n    /**\n     * 批量上传的时候，保存的 xhrRequesting 对象\n     * 如果需要 abort 的时候，从这里来获取\n     */\n    this.xhrPools = [];\n}\nutils.inherits(MultipartTask, Task);\n\nMultipartTask.prototype.start = function () {\n    if (this.aborted) {\n        return Q.resolve();\n    }\n\n    var self = this;\n\n    var dispatcher = this.eventDispatcher;\n\n    var file = this.options.file;\n    var bucket = this.options.bucket;\n    var object = this.options.object;\n    var metas = this.options.metas;\n    var chunkSize = this.options.chunk_size;\n    var multipartParallel = this.options.bos_multipart_parallel;\n\n    var contentType = utils.guessContentType(file);\n    var options = {'Content-Type': contentType};\n    var uploadId = null;\n\n    return this._initiateMultipartUpload(file, chunkSize, bucket, object, options)\n        .then(function (response) {\n            uploadId = response.body.uploadId;\n            var parts = response.body.parts || [];\n            // 准备 uploadParts\n            var deferred = Q.defer();\n            var tasks = utils.getTasks(file, uploadId, chunkSize, bucket, object);\n            utils.filterTasks(tasks, parts);\n\n            var loaded = parts.length;\n            // 这个用来记录整体 Parts 的上传进度，不是单个 Part 的上传进度\n            // 单个 Part 的上传进度可以监听 kUploadPartProgress 来得到\n            var state = {\n                lengthComputable: true,\n                loaded: loaded,\n                total: tasks.length\n            };\n            file._previousLoaded = loaded * chunkSize;\n            if (loaded) {\n                var progress = file._previousLoaded / file.size;\n                dispatcher.dispatchEvent(events.kUploadProgress, [file, progress, null]);\n            }\n\n            async.mapLimit(tasks, multipartParallel, self._uploadPart(state),\n                function (err, results) {\n                    if (err) {\n                        deferred.reject(err);\n                    }\n                    else {\n                        deferred.resolve(results);\n                    }\n                });\n\n            return deferred.promise;\n        })\n        .then(function (responses) {\n            var partList = [];\n            u.each(responses, function (response, index) {\n                partList.push({\n                    partNumber: index + 1,\n                    eTag: response.http_headers.etag\n                });\n            });\n            // 全部上传结束后删除localStorage\n            self._generateLocalKey({\n                blob: file,\n                chunkSize: chunkSize,\n                bucket: bucket,\n                object: object\n            }).then(function (key) {\n                utils.removeUploadId(key);\n            });\n            return self.client.completeMultipartUpload(bucket, object, uploadId, partList, metas);\n        })\n        .then(function (response) {\n            dispatcher.dispatchEvent(events.kUploadProgress, [file, 1]);\n\n            response.body.bucket = bucket;\n            response.body.object = object;\n\n            dispatcher.dispatchEvent(events.kFileUploaded, [file, response]);\n        })[\n        \"catch\"](function (error) {\n            var eventType = self.aborted ? events.kAborted : events.kError;\n            dispatcher.dispatchEvent(eventType, [error, file]);\n        });\n};\n\n\nMultipartTask.prototype._initiateMultipartUpload = function (file, chunkSize, bucket, object, options) {\n    var self = this;\n    var dispatcher = this.eventDispatcher;\n\n    var uploadId;\n    var localSaveKey;\n\n    function initNewMultipartUpload() {\n        return self.client.initiateMultipartUpload(bucket, object, options)\n            .then(function (response) {\n                if (localSaveKey) {\n                    utils.setUploadId(localSaveKey, response.body.uploadId);\n                }\n\n                response.body.parts = [];\n                return response;\n            });\n    }\n\n    var keyOptions = {\n        blob: file,\n        chunkSize: chunkSize,\n        bucket: bucket,\n        object: object\n    };\n    var promise = this.options.bos_multipart_auto_continue\n        ? this._generateLocalKey(keyOptions)\n        : Q.resolve(null);\n\n    return promise.then(function (key) {\n            localSaveKey = key;\n            if (!localSaveKey) {\n                return initNewMultipartUpload();\n            }\n\n            uploadId = utils.getUploadId(localSaveKey);\n            if (!uploadId) {\n                return initNewMultipartUpload();\n            }\n\n            return self._listParts(file, bucket, object, uploadId);\n        })\n        .then(function (response) {\n            if (uploadId && localSaveKey) {\n                var parts = response.body.parts;\n                // listParts 的返回结果\n                dispatcher.dispatchEvent(events.kUploadResume, [file, parts, null]);\n                response.body.uploadId = uploadId;\n            }\n            return response;\n        })[\n        \"catch\"](function (error) {\n            if (uploadId && localSaveKey) {\n                // 如果获取已上传分片失败，则重新上传。\n                dispatcher.dispatchEvent(events.kUploadResumeError, [file, error, null]);\n                utils.removeUploadId(localSaveKey);\n                return initNewMultipartUpload();\n            }\n            throw error;\n        });\n};\n\nMultipartTask.prototype._generateLocalKey = function (options) {\n    var generator = this.options.bos_multipart_local_key_generator;\n    return utils.generateLocalKey(options, generator);\n};\n\nMultipartTask.prototype._listParts = function (file, bucket, object, uploadId) {\n    var self = this;\n    var dispatcher = this.eventDispatcher;\n\n    var localParts = dispatcher.dispatchEvent(events.kListParts, [file, uploadId]);\n\n    return Q.resolve(localParts)\n        .then(function (parts) {\n            if (u.isArray(parts) && parts.length) {\n                return {\n                    http_headers: {},\n                    body: {\n                        parts: parts\n                    }\n                };\n            }\n\n            // 如果返回的不是数组，就调用 listParts 接口从服务器获取数据\n            return self._listAllParts(bucket, object, uploadId);\n        });\n};\n\nMultipartTask.prototype._listAllParts = function (bucket, object, uploadId) {\n    // isTruncated === true / false\n    var self = this;\n    var deferred = Q.defer();\n\n    var parts = [];\n    var payload = null;\n    var maxParts = 1000;          // 每次的分页\n    var partNumberMarker = 0;     // 分隔符\n\n    function listParts() {\n        var options = {\n            maxParts: maxParts,\n            partNumberMarker: partNumberMarker\n        };\n        self.client.listParts(bucket, object, uploadId, options)\n            .then(function (response) {\n                if (payload == null) {\n                    payload = response;\n                }\n\n                parts.push.apply(parts, response.body.parts);\n                partNumberMarker = response.body.nextPartNumberMarker;\n\n                if (response.body.isTruncated === false) {\n                    // 结束了\n                    payload.body.parts = parts;\n                    deferred.resolve(payload);\n                }\n                else {\n                    // 递归调用\n                    listParts();\n                }\n            })[\n            \"catch\"](function (error) {\n                deferred.reject(error);\n            });\n    }\n    listParts();\n\n    return deferred.promise;\n};\n\nMultipartTask.prototype._uploadPart = function (state) {\n    var self = this;\n    var dispatcher = this.eventDispatcher;\n\n    function uploadPartInner(item, opt_maxRetries) {\n        if (item.etag) {\n            self.networkInfo.loadedBytes += item.partSize;\n\n            // 跳过已上传的part\n            return Q.resolve({\n                http_headers: {\n                    etag: item.etag\n                },\n                body: {}\n            });\n        }\n        var maxRetries = opt_maxRetries == null\n            ? self.options.max_retries\n            : opt_maxRetries;\n        var retryInterval = self.options.retry_interval;\n\n        var blob = item.file.slice(item.start, item.stop + 1);\n        blob._parentUUID = item.file.uuid;    // 后续根据分片来查找原始文件的时候，会用到\n        blob._previousLoaded = 0;\n\n        var uploadPartXhr = self.client.uploadPartFromBlob(item.bucket, item.object,\n            item.uploadId, item.partNumber, item.partSize, blob);\n        var xhrPoolIndex = self.xhrPools.push(uploadPartXhr);\n\n        return uploadPartXhr.then(function (response) {\n                ++state.loaded;\n                // var progress = state.loaded / state.total;\n                // dispatcher.dispatchEvent(events.kUploadProgress, [item.file, progress, null]);\n\n                var result = {\n                    uploadId: item.uploadId,\n                    partNumber: item.partNumber,\n                    partSize: item.partSize,\n                    bucket: item.bucket,\n                    object: item.object,\n                    offset: item.start,\n                    total: blob.size,\n                    response: response\n                };\n                dispatcher.dispatchEvent(events.kChunkUploaded, [item.file, result]);\n\n                // 不用删除，设置为 null 就好了，反正 abort 的时候会判断的\n                self.xhrPools[xhrPoolIndex - 1] = null;\n\n                return response;\n            })[\n            \"catch\"](function (error) {\n                if (maxRetries > 0 && !self.aborted) {\n                    // 还有重试的机会\n                    return utils.delay(retryInterval).then(function () {\n                        return uploadPartInner(item, maxRetries - 1);\n                    });\n                }\n                // 没有机会重试了 :-(\n                throw error;\n            });\n\n    }\n\n    return function (item, callback) {\n        // file: file,\n        // uploadId: uploadId,\n        // bucket: bucket,\n        // object: object,\n        // partNumber: partNumber,\n        // partSize: partSize,\n        // start: offset,\n        // stop: offset + partSize - 1\n\n        var resolve = function (response) {\n            callback(null, response);\n        };\n        var reject = function (error) {\n            callback(error);\n        };\n\n        uploadPartInner(item).then(resolve, reject);\n    };\n};\n\n/**\n * 终止上传任务\n */\nMultipartTask.prototype.abort = function () {\n    this.aborted = true;\n    this.xhrRequesting = null;\n    for (var i = 0; i < this.xhrPools.length; i++) {\n        var xhr = this.xhrPools[i];\n        if (xhr && typeof xhr.abort === 'function') {\n            xhr.abort();\n        }\n    }\n};\n\n\nmodule.exports = MultipartTask;\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file src/network_info.js\n * @author leeight\n */\n\nvar utils = require(32);\n\n/**\n * NetworkInfo\n *\n * @class\n */\nfunction NetworkInfo() {\n    /**\n     * 记录从 start 开始已经上传的字节数.\n     * @type {number}\n     */\n    this.loadedBytes = 0;\n\n    /**\n     * 记录队列中总文件的大小, UploadComplete 之后会被清零\n     * @type {number}\n     */\n    this.totalBytes = 0;\n\n    /**\n     * 记录开始上传的时间.\n     * @type {number}\n     */\n    this._startTime = utils.now();\n\n    this.reset();\n}\n\nNetworkInfo.prototype.dump = function () {\n    return [\n        this.loadedBytes,                     // 已经上传的\n        utils.now() - this._startTime,        // 花费的时间\n        this.totalBytes - this.loadedBytes    // 剩余未上传的\n    ];\n};\n\nNetworkInfo.prototype.reset = function () {\n    this.loadedBytes = 0;\n    this._startTime = utils.now();\n};\n\nmodule.exports = NetworkInfo;\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file put_object_task.js\n * @author leeight\n */\n\nvar Q = require(44);\nvar u = require(46);\nvar utils = require(32);\nvar events = require(24);\nvar Task = require(30);\n\n/**\n * PutObjectTask\n *\n * @class\n */\nfunction PutObjectTask() {\n    Task.apply(this, arguments);\n}\nutils.inherits(PutObjectTask, Task);\n\nPutObjectTask.prototype.start = function (opt_maxRetries) {\n    if (this.aborted) {\n        return Q.resolve();\n    }\n\n    var self = this;\n\n    var dispatcher = this.eventDispatcher;\n\n    var file = this.options.file;\n    var bucket = this.options.bucket;\n    var object = this.options.object;\n    var metas = this.options.metas;\n    var maxRetries = opt_maxRetries == null\n        ? this.options.max_retries\n        : opt_maxRetries;\n    var retryInterval = this.options.retry_interval;\n\n    var contentType = utils.guessContentType(file);\n    var options = u.extend({'Content-Type': contentType}, metas);\n\n    this.xhrRequesting = this.client.putObjectFromBlob(bucket, object, file, options);\n\n    return this.xhrRequesting.then(function (response) {\n        dispatcher.dispatchEvent(events.kUploadProgress, [file, 1]);\n\n        response.body.bucket = bucket;\n        response.body.key = object;\n\n        dispatcher.dispatchEvent(events.kFileUploaded, [file, response]);\n    })[\n    \"catch\"](function (error) {\n        var eventType = self.aborted ? events.kAborted : events.kError;\n        dispatcher.dispatchEvent(eventType, [error, file]);\n\n        if (error.status_code && error.code && error.request_id) {\n            // 应该是正常的错误(比如签名异常)，这种情况就不要重试了\n            return Q.resolve();\n        }\n        // else if (error.status_code === 0) {\n        //    // 可能是断网了，safari 触发 online/offline 延迟比较久\n        //    // 我们推迟一下 self._uploadNext() 的时机\n        //    self.pause();\n        //    return;\n        // }\n        else if (maxRetries > 0 && !self.aborted) {\n            // 还有机会重试\n            return utils.delay(retryInterval).then(function () {\n                return self.start(maxRetries - 1);\n            });\n        }\n\n        // 重试结束了，不管了，继续下一个文件的上传\n        return Q.resolve();\n    });\n};\n\n\nmodule.exports = PutObjectTask;\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file src/queue.js\n * @author leeight\n */\n\n/**\n * Queue\n *\n * @class\n * @param {*} collection The collection.\n */\nfunction Queue(collection) {\n    this.collection = collection;\n}\n\nQueue.prototype.isEmpty = function () {\n    return this.collection.length <= 0;\n};\n\nQueue.prototype.size = function () {\n    return this.collection.length;\n};\n\nQueue.prototype.dequeue = function () {\n    return this.collection.shift();\n};\n\nmodule.exports = Queue;\n\n\n\n\n\n\n\n\n\n\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file sts_token_manager.js\n * @author leeight\n */\n\nvar Q = require(44);\nvar utils = require(32);\n\n/**\n * StsTokenManager\n *\n * @class\n * @param {Object} options The options.\n */\nfunction StsTokenManager(options) {\n    this.options = options;\n\n    this._cache = {};\n}\n\nStsTokenManager.prototype.get = function (bucket) {\n    var self = this;\n\n    if (self._cache[bucket] != null) {\n        return self._cache[bucket];\n    }\n\n    return Q.resolve(this._getImpl.apply(this, arguments)).then(function (payload) {\n        self._cache[bucket] = payload;\n        return payload;\n    });\n};\n\nStsTokenManager.prototype._getImpl = function (bucket) {\n    var options = this.options;\n    var uptoken_url = options.uptoken_url;\n    var timeout = options.uptoken_timeout || options.uptoken_jsonp_timeout;\n    var viaJsonp = options.uptoken_via_jsonp;\n\n    var deferred = Q.defer();\n    $.ajax({\n        url: uptoken_url,\n        jsonp: viaJsonp ? 'callback' : false,\n        dataType: viaJsonp ? 'jsonp' : 'json',\n        timeout: timeout,\n        data: {\n            sts: JSON.stringify(utils.getDefaultACL(bucket))\n        },\n        success: function (payload) {\n            // payload.AccessKeyId\n            // payload.SecretAccessKey\n            // payload.SessionToken\n            // payload.Expiration\n            deferred.resolve(payload);\n        },\n        error: function () {\n            deferred.reject(new Error('Get sts token timeout (' + timeout + 'ms).'));\n        }\n    });\n\n    return deferred.promise;\n};\n\nmodule.exports = StsTokenManager;\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file task.js\n * @author leeight\n */\n\n\n/**\n * 不同的场景下，需要通过不同的Task来完成上传的工作\n *\n * @param {sdk.BosClient} client The bos client.\n * @param {EventDispatcher} eventDispatcher The event dispatcher.\n * @param {Object} options The extra task-related arguments.\n *\n * @constructor\n */\nfunction Task(client, eventDispatcher, options) {\n    /**\n     * 可以被 abort 的 promise 对象\n     *\n     * @type {Promise}\n     */\n    this.xhrRequesting = null;\n\n    /**\n     * 标记一下是否是人为中断了\n     *\n     * @type {boolean}\n     */\n    this.aborted = false;\n\n    this.networkInfo = null;\n\n    this.client = client;\n    this.eventDispatcher = eventDispatcher;\n    this.options = options;\n}\n\nfunction abstractMethod() {\n    throw new Error('unimplemented method.');\n}\n\n/**\n * 开始上传任务\n */\nTask.prototype.start = abstractMethod;\n\n/**\n * 暂停上传\n */\nTask.prototype.pause = abstractMethod;\n\n/**\n * 恢复暂停\n */\nTask.prototype.resume = abstractMethod;\n\nTask.prototype.setNetworkInfo = function (networkInfo) {\n    this.networkInfo = networkInfo;\n};\n\n/**\n * 终止上传任务\n */\nTask.prototype.abort = function () {\n    if (this.xhrRequesting\n        && typeof this.xhrRequesting.abort === 'function') {\n        this.aborted = true;\n        this.xhrRequesting.abort();\n        this.xhrRequesting = null;\n    }\n};\n\nmodule.exports = Task;\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file uploader.js\n * @author leeight\n */\n\nvar Q = require(44);\nvar u = require(46);\nvar utils = require(32);\nvar events = require(24);\nvar kDefaultOptions = require(23);\nvar PutObjectTask = require(27);\nvar MultipartTask = require(25);\nvar StsTokenManager = require(29);\nvar NetworkInfo = require(26);\n\nvar Auth = require(15);\nvar BosClient = require(17);\n\n/**\n * BCE BOS Uploader\n *\n * @constructor\n * @param {Object|string} options 配置参数\n */\nfunction Uploader(options) {\n    if (u.isString(options)) {\n        // 支持简便的写法，可以从 DOM 里面分析相关的配置.\n        options = u.extend({\n            browse_button: options,\n            auto_start: true\n        }, $(options).data());\n    }\n\n    var runtimeOptions = {};\n    this.options = u.extend({}, kDefaultOptions, runtimeOptions, options);\n    this.options.max_file_size = utils.parseSize(this.options.max_file_size);\n    this.options.bos_multipart_min_size\n        = utils.parseSize(this.options.bos_multipart_min_size);\n    this.options.chunk_size = utils.parseSize(this.options.chunk_size);\n\n    var credentials = this.options.bos_credentials;\n    if (!credentials && this.options.bos_ak && this.options.bos_sk) {\n        this.options.bos_credentials = {\n            ak: this.options.bos_ak,\n            sk: this.options.bos_sk\n        };\n    }\n\n    /**\n     * @type {BosClient}\n     */\n    this.client = new BosClient({\n        endpoint: utils.normalizeEndpoint(this.options.bos_endpoint),\n        credentials: this.options.bos_credentials,\n        sessionToken: this.options.uptoken\n    });\n\n    /**\n     * 需要等待上传的文件列表，每次上传的时候，从这里面删除\n     * 成功或者失败都不会再放回去了\n     * @param {Array.<File>}\n     */\n    this._files = [];\n\n    /**\n     * 正在上传的文件列表.\n     *\n     * @type {Object.<string, File>}\n     */\n    this._uploadingFiles = {};\n\n    /**\n     * 是否被中断了，比如 this.stop\n     * @type {boolean}\n     */\n    this._abort = false;\n\n    /**\n     * 是否处于上传的过程中，也就是正在处理 this._files 队列的内容.\n     * @type {boolean}\n     */\n    this._working = false;\n\n    /**\n     * 是否支持xhr2\n     * @type {boolean}\n     */\n    this._xhr2Supported = utils.isXhr2Supported();\n\n    this._networkInfo = new NetworkInfo();\n\n    this._init();\n}\n\nUploader.prototype._getCustomizedSignature = function (uptokenUrl) {\n    var options = this.options;\n    var timeout = options.uptoken_timeout || options.uptoken_jsonp_timeout;\n    var viaJsonp = options.uptoken_via_jsonp;\n\n    return function (_, httpMethod, path, params, headers) {\n        if (/\\bed=([\\w\\.]+)\\b/.test(location.search)) {\n            headers.Host = RegExp.$1;\n        }\n\n        if (u.isArray(options.auth_stripped_headers)) {\n            headers = u.omit(headers, options.auth_stripped_headers);\n        }\n\n        var deferred = Q.defer();\n        $.ajax({\n            url: uptokenUrl,\n            jsonp: viaJsonp ? 'callback' : false,\n            dataType: viaJsonp ? 'jsonp' : 'json',\n            timeout: timeout,\n            data: {\n                httpMethod: httpMethod,\n                path: path,\n                // delay: ~~(Math.random() * 10),\n                queries: JSON.stringify(params || {}),\n                headers: JSON.stringify(headers || {})\n            },\n            error: function () {\n                deferred.reject(new Error('Get authorization timeout (' + timeout + 'ms).'));\n            },\n            success: function (payload) {\n                if (payload.statusCode === 200 && payload.signature) {\n                    deferred.resolve(payload.signature, payload.xbceDate);\n                }\n                else {\n                    deferred.reject(new Error('createSignature failed, statusCode = ' + payload.statusCode));\n                }\n            }\n        });\n        return deferred.promise;\n    };\n};\n\n/**\n * 调用 this.options.init 里面配置的方法\n *\n * @param {string} methodName 方法名称\n * @param {Array.<*>} args 调用时候的参数.\n * @param {boolean=} throwErrors 如果发生异常的时候，是否需要抛出来\n * @return {*} 事件的返回值.\n */\nUploader.prototype._invoke = function (methodName, args, throwErrors) {\n    var init = this.options.init || this.options.Init;\n    if (!init) {\n        return;\n    }\n\n    var method = init[methodName];\n    if (typeof method !== 'function') {\n        return;\n    }\n\n    try {\n        var up = null;\n        args = args == null ? [up] : [up].concat(args);\n        return method.apply(null, args);\n    }\n    catch (ex) {\n        if (throwErrors === true) {\n            return Q.reject(ex);\n        }\n    }\n};\n\n/**\n * 初始化控件.\n */\nUploader.prototype._init = function () {\n    var options = this.options;\n    var accept = options.accept;\n\n    var btnElement = $(options.browse_button);\n    var nodeName = btnElement.prop('nodeName');\n    if (nodeName !== 'INPUT') {\n        var elementContainer = btnElement;\n\n        // 如果本身不是 <input type=\"file\" />，自动追加一个上去\n        // 1. options.browse_button 后面追加一个元素 <div><input type=\"file\" /></div>\n        // 2. btnElement.parent().css('position', 'relative');\n        // 3. .bce-bos-uploader-input-container 用来自定义自己的样式\n        var width = elementContainer.outerWidth();\n        var height = elementContainer.outerHeight();\n\n        var inputElementContainer = $('<div class=\"bce-bos-uploader-input-container\"><input type=\"file\" /></div>');\n        inputElementContainer.css({\n            'position': 'absolute',\n            'top': 0, 'left': 0,\n            'width': width, 'height': height,\n            'overflow': 'hidden',\n            // 如果支持 xhr2，把 input[type=file] 放到按钮的下面，通过主动调用 file.click() 触发\n            // 如果不支持xhr2, 把 input[type=file] 放到按钮的上面，通过用户主动点击 input[type=file] 触发\n            'z-index': this._xhr2Supported ? 99 : 100\n        });\n        inputElementContainer.find('input').css({\n            'position': 'absolute',\n            'top': 0, 'left': 0,\n            'width': '100%', 'height': '100%',\n            'font-size': '999px',\n            'opacity': 0\n        });\n        elementContainer.css({\n            'position': 'relative',\n            'z-index': this._xhr2Supported ? 100 : 99\n        });\n        elementContainer.after(inputElementContainer);\n        elementContainer.parent().css('position', 'relative');\n\n        // 把 browse_button 修改为当前生成的那个元素\n        options.browse_button = inputElementContainer.find('input');\n\n        if (this._xhr2Supported) {\n            elementContainer.click(function () {\n                options.browse_button.click();\n            });\n        }\n    }\n\n    var self = this;\n    if (!this._xhr2Supported\n        && typeof mOxie !== 'undefined'\n        && u.isFunction(mOxie.FileInput)) {\n        // https://github.com/moxiecode/moxie/wiki/FileInput\n        // mOxie.FileInput 只支持\n        // [+]: browse_button, accept multiple, directory, file\n        // [x]: container, required_caps\n        var fileInput = new mOxie.FileInput({\n            runtime_order: 'flash,html4',\n            browse_button: $(options.browse_button).get(0),\n            swf_url: options.flash_swf_url,\n            accept: utils.expandAcceptToArray(accept),\n            multiple: options.multi_selection,\n            directory: options.dir_selection,\n            file: 'file'      // PostObject接口要求固定是 'file'\n        });\n\n        fileInput.onchange = u.bind(this._onFilesAdded, this);\n        fileInput.onready = function () {\n            self._initEvents();\n            self._invoke(events.kPostInit);\n        };\n\n        fileInput.init();\n    }\n\n    var promise = options.bos_credentials\n        ? Q.resolve()\n        : self.refreshStsToken();\n\n    promise.then(function () {\n        if (options.bos_credentials) {\n            self.client.createSignature = function (_, httpMethod, path, params, headers) {\n                var credentials = _ || this.config.credentials;\n                return Q.fcall(function () {\n                    var auth = new Auth(credentials.ak, credentials.sk);\n                    return auth.generateAuthorization(httpMethod, path, params, headers);\n                });\n            };\n        }\n        else if (options.uptoken_url && options.get_new_uptoken === true) {\n            // 服务端动态签名的方式\n            self.client.createSignature = self._getCustomizedSignature(options.uptoken_url);\n        }\n\n        if (self._xhr2Supported) {\n            // 对于不支持 xhr2 的情况，会在 onready 的时候去触发事件\n            self._initEvents();\n            self._invoke(events.kPostInit);\n        }\n    })[\"catch\"](function (error) {\n        self._invoke(events.kError, [error]);\n    });\n};\n\nUploader.prototype._initEvents = function () {\n    var options = this.options;\n\n    if (this._xhr2Supported) {\n        var btn = $(options.browse_button);\n        if (btn.attr('multiple') == null) {\n            // 如果用户没有显示的设置过 multiple，使用 multi_selection 的设置\n            // 否则保留 <input multiple /> 的内容\n            btn.attr('multiple', !!options.multi_selection);\n        }\n        btn.on('change', u.bind(this._onFilesAdded, this));\n\n        var accept = options.accept;\n        if (accept != null) {\n            // Safari 只支持 mime-type\n            // Chrome 支持 mime-type 和 exts\n            // Firefox 只支持 exts\n            // NOTE: exts 必须有 . 这个前缀，例如 .txt 是合法的，txt 是不合法的\n            var exts = utils.expandAccept(accept);\n            var isSafari = /Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor);\n            if (isSafari) {\n                exts = utils.extToMimeType(exts);\n            }\n            btn.attr('accept', exts);\n        }\n\n        if (options.dir_selection) {\n            btn.attr('directory', true);\n            btn.attr('mozdirectory', true);\n            btn.attr('webkitdirectory', true);\n        }\n    }\n\n    this.client.on('progress', u.bind(this._onUploadProgress, this));\n    // XXX 必须绑定 error 的处理函数，否则会 throw new Error\n    this.client.on('error', u.bind(this._onError, this));\n\n    // $(window).on('online', u.bind(this._handleOnlineStatus, this));\n    // $(window).on('offline', u.bind(this._handleOfflineStatus, this));\n\n    if (!this._xhr2Supported) {\n        // 如果浏览器不支持 xhr2，那么就切换到 mOxie.XMLHttpRequest\n        // 但是因为 mOxie.XMLHttpRequest 无法发送 HEAD 请求，无法获取 Response Headers，\n        // 因此 getObjectMetadata实际上无法正常工作，因此我们需要：\n        // 1. 让 BOS 新增 REST API，在 GET 的请求的同时，把 x-bce-* 放到 Response Body 返回\n        // 2. 临时方案：新增一个 Relay 服务，实现方案 1\n        //    GET /bj.bcebos.com/v1/bucket/object?httpMethod=HEAD\n        //    Host: relay.efe.tech\n        //    Authorization: xxx\n        // options.bos_relay_server\n        // options.swf_url\n        this.client.sendHTTPRequest = u.bind(utils.fixXhr(this.options, true), this.client);\n    }\n};\n\nUploader.prototype._filterFiles = function (candidates) {\n    var self = this;\n\n    // 如果 maxFileSize === 0 就说明不限制大小\n    var maxFileSize = this.options.max_file_size;\n\n    var files = u.filter(candidates, function (file) {\n        if (maxFileSize > 0 && file.size > maxFileSize) {\n            self._invoke(events.kFileFiltered, [file]);\n            return false;\n        }\n\n        // TODO\n        // 检查后缀之类的\n\n        return true;\n    });\n\n    return this._invoke(events.kFilesFilter, [files]) || files;\n};\n\nUploader.prototype._onFilesAdded = function (e) {\n    var files = e.target.files;\n    if (!files) {\n        // IE7, IE8 低版本浏览器的处理\n        var name = e.target.value.split(/[\\/\\\\]/).pop();\n        files = [\n            {name: name, size: 0}\n        ];\n    }\n    files = this._filterFiles(files);\n    if (u.isArray(files) && files.length) {\n        this.addFiles(files);\n    }\n\n    if (this.options.auto_start) {\n        this.start();\n    }\n};\n\nUploader.prototype._onError = function (e) {\n};\n\n/**\n * 处理上传进度的回掉函数.\n * 1. 这里要区分文件的上传还是分片的上传，分片的上传是通过 partNumber 和 uploadId 的组合来判断的\n * 2. IE6,7,8,9下面，是不需要考虑的，因为不会触发这个事件，而是直接在 _sendPostRequest 触发 kUploadProgress 了\n * 3. 其它情况下，我们判断一下 Request Body 的类型是否是 Blob，从而避免对于其它类型的请求，触发 kUploadProgress\n *    例如：HEAD，GET，POST(InitMultipart) 的时候，是没必要触发 kUploadProgress 的\n *\n * @param {Object} e  Progress Event 对象.\n * @param {Object} httpContext sendHTTPRequest 的参数\n */\nUploader.prototype._onUploadProgress = function (e, httpContext) {\n    var args = httpContext.args;\n    var file = args.body;\n\n    if (!utils.isBlob(file)) {\n        return;\n    }\n\n    var progress = e.lengthComputable\n        ? e.loaded / e.total\n        : 0;\n    var delta = e.loaded - file._previousLoaded;\n    this._networkInfo.loadedBytes += delta;\n    this._invoke(events.kNetworkSpeed, this._networkInfo.dump());\n    file._previousLoaded = e.loaded;\n\n    var eventType = events.kUploadProgress;\n    if (args.params.partNumber && args.params.uploadId) {\n        // IE6,7,8,9下面不会有partNumber和uploadId\n        // 此时的 file 是 slice 的结果，可能没有自定义的属性\n        // 比如 demo 里面的 __id, __mediaId 之类的\n        eventType = events.kUploadPartProgress;\n        this._invoke(eventType, [file, progress, e]);\n\n        // 然后需要从 file 获取原始的文件（因为 file 此时是一个分片）\n        // 之后再触发一次 events.kUploadProgress 的事件\n        var uuid = file._parentUUID;\n        var originalFile = this._uploadingFiles[uuid];\n        var originalFileProgress = 0;\n        if (originalFile) {\n            originalFile._previousLoaded += delta;\n            originalFileProgress = Math.min(originalFile._previousLoaded / originalFile.size, 1);\n            this._invoke(events.kUploadProgress, [originalFile, originalFileProgress, null]);\n        }\n    }\n    else {\n        this._invoke(eventType, [file, progress, e]);\n    }\n};\n\nUploader.prototype.addFiles = function (files) {\n    function buildAbortHandler(item, self) {\n        return function () {\n            item._aborted = true;\n            self._invoke(events.kAborted, [null, item]);\n        };\n    }\n\n    var totalBytes = 0;\n    for (var i = 0; i < files.length; i++) {\n        var item = files[i];\n\n        // 这里是 abort 的默认实现，开始上传的时候，会改成另外的一种实现方式\n        // 默认的实现是为了支持在没有开始上传之前，也可以取消上传的需求\n        item.abort = buildAbortHandler(item, this);\n\n        // 内部的 uuid，外部也可以使用，比如 remove(item.uuid) / remove(item)\n        item.uuid = utils.uuid();\n\n        totalBytes += item.size;\n    }\n    this._networkInfo.totalBytes += totalBytes;\n    this._files.push.apply(this._files, files);\n    this._invoke(events.kFilesAdded, [files]);\n};\n\nUploader.prototype.addFile = function (file) {\n    this.addFiles([file]);\n};\n\nUploader.prototype.remove = function (item) {\n    if (typeof item === 'string') {\n        item = this._uploadingFiles[item] || u.find(this._files, function (file) {\n            return file.uuid === item;\n        });\n    }\n\n    if (item && typeof item.abort === 'function') {\n        item.abort();\n    }\n};\n\nUploader.prototype.start = function () {\n    var self = this;\n\n    if (this._working) {\n        return;\n    }\n\n    if (this._files.length) {\n        this._working = true;\n        this._abort = false;\n        this._networkInfo.reset();\n\n        var taskParallel = this.options.bos_task_parallel;\n        // 这里没有使用 async.eachLimit 的原因是 this._files 可能会被动态的修改\n        utils.eachLimit(this._files, taskParallel,\n            function (file, callback) {\n                file._previousLoaded = 0;\n                self._uploadNext(file)\n                    .then(function () {\n                        // fulfillment\n                        delete self._uploadingFiles[file.uuid];\n                        callback(null, file);\n                    })[\n                    \"catch\"](function () {\n                        // rejection\n                        delete self._uploadingFiles[file.uuid];\n                        callback(null, file);\n                    });\n            },\n            function (error) {\n                self._working = false;\n                self._files.length = 0;\n                self._networkInfo.totalBytes = 0;\n                self._invoke(events.kUploadComplete);\n            });\n    }\n};\n\nUploader.prototype.stop = function () {\n    this._abort = true;\n    this._working = false;\n};\n\n/**\n * 动态设置 Uploader 的某些参数，当前只支持动态的修改\n * bos_credentials, uptoken, bos_bucket, bos_endpoint\n * bos_ak, bos_sk\n *\n * @param {Object} options 用户动态设置的参数（只支持部分）\n */\nUploader.prototype.setOptions = function (options) {\n    var supportedOptions = u.pick(options, 'bos_credentials',\n        'bos_ak', 'bos_sk', 'uptoken', 'bos_bucket', 'bos_endpoint');\n    this.options = u.extend(this.options, supportedOptions);\n\n    var config = this.client && this.client.config;\n    if (config) {\n        var credentials = null;\n\n        if (options.bos_credentials) {\n            credentials = options.bos_credentials;\n        }\n        else if (options.bos_ak && options.bos_sk) {\n            credentials = {\n                ak: options.bos_ak,\n                sk: options.bos_sk\n            };\n        }\n\n        if (credentials) {\n            this.options.bos_credentials = credentials;\n            config.credentials = credentials;\n        }\n        if (options.uptoken) {\n            config.sessionToken = options.uptoken;\n        }\n        if (options.bos_endpoint) {\n            config.endpoint = utils.normalizeEndpoint(options.bos_endpoint);\n        }\n    }\n};\n\n/**\n * 有的用户希望主动更新 sts token，避免过期的问题\n *\n * @return {Promise}\n */\nUploader.prototype.refreshStsToken = function () {\n    var self = this;\n    var options = self.options;\n    var stsMode = true // self._xhr2Supported\n        && options.bos_bucket\n        && options.uptoken_url\n        && options.get_new_uptoken === false;\n    if (stsMode) {\n        var stm = new StsTokenManager(options);\n        return stm.get(options.bos_bucket).then(function (payload) {\n            return self.setOptions({\n                bos_ak: payload.AccessKeyId,\n                bos_sk: payload.SecretAccessKey,\n                uptoken: payload.SessionToken\n            });\n        });\n    }\n    return Q.resolve();\n};\n\nUploader.prototype._uploadNext = function (file) {\n    if (this._abort) {\n        this._working = false;\n        return Q.resolve();\n    }\n\n    if (file._aborted === true) {\n        return Q.resolve();\n    }\n\n    var throwErrors = true;\n    var returnValue = this._invoke(events.kBeforeUpload, [file], throwErrors);\n    if (returnValue === false) {\n        return Q.resolve();\n    }\n\n    var self = this;\n    return Q.resolve(returnValue)\n        .then(function () {\n            return self._uploadNextImpl(file);\n        })[\n        \"catch\"](function (error) {\n            self._invoke(events.kError, [error, file]);\n        });\n};\n\nUploader.prototype._uploadNextImpl = function (file) {\n    var self = this;\n    var options = this.options;\n    var object = file.name;\n    var throwErrors = true;\n\n    var defaultTaskOptions = u.pick(options,\n        'flash_swf_url', 'max_retries', 'chunk_size', 'retry_interval',\n        'bos_multipart_parallel',\n        'bos_multipart_auto_continue',\n        'bos_multipart_local_key_generator'\n    );\n    return Q.all([\n        this._invoke(events.kKey, [file], throwErrors),\n        this._invoke(events.kObjectMetas, [file])\n    ]).then(function (array) {\n        // options.bos_bucket 可能会被 kKey 事件动态的改变\n        var bucket = options.bos_bucket;\n\n        var result = array[0];\n        var objectMetas = array[1];\n\n        var multipart = 'auto';\n        if (u.isString(result)) {\n            object = result;\n        }\n        else if (u.isObject(result)) {\n            bucket = result.bucket || bucket;\n            object = result.key || object;\n\n            // 'auto' / 'off'\n            multipart = result.multipart || multipart;\n        }\n\n        var client = self.client;\n        var eventDispatcher = self;\n        var taskOptions = u.extend(defaultTaskOptions, {\n            file: file,\n            bucket: bucket,\n            object: object,\n            metas: objectMetas\n        });\n\n        var TaskConstructor = PutObjectTask;\n        if (multipart === 'auto'\n            // 对于 moxie.XMLHttpRequest 来说，无法获取 getResponseHeader('ETag')\n            // 导致在 completeMultipartUpload 的时候，无法传递正确的参数\n            // 因此需要禁止使用 moxie.XMLHttpRequest 使用 MultipartTask\n            // 除非用自己本地计算的 md5 作为 getResponseHeader('ETag') 的代替值，不过还是有一些问题：\n            // 1. MultipartTask 需要对文件进行分片，但是使用 moxie.XMLHttpRequest 的时候，明显有卡顿的问题（因为 Flash 把整个文件都读取到内存中，然后再分片）\n            //    导致处理大文件的时候性能很差\n            // 2. 本地计算 md5 需要额外引入库，导致 bce-bos-uploader 的体积变大\n            // 综上所述，在使用 moxie 的时候，禁止 MultipartTask\n            && self._xhr2Supported\n            && file.size > options.bos_multipart_min_size) {\n            TaskConstructor = MultipartTask;\n        }\n        var task = new TaskConstructor(client, eventDispatcher, taskOptions);\n\n        self._uploadingFiles[file.uuid] = file;\n\n        file.abort = function () {\n            file._aborted = true;\n            return task.abort();\n        };\n\n        task.setNetworkInfo(self._networkInfo);\n        return task.start();\n    });\n};\n\nUploader.prototype.dispatchEvent = function (eventName, eventArguments, throwErrors) {\n    if (eventName === events.kAborted\n        && eventArguments\n        && eventArguments[1]) {\n        var file = eventArguments[1];\n        if (file.size > 0) {\n            var loadedSize = file._previousLoaded || 0;\n            this._networkInfo.totalBytes -= (file.size - loadedSize);\n            this._invoke(events.kNetworkSpeed, this._networkInfo.dump());\n        }\n    }\n    return this._invoke(eventName, eventArguments, throwErrors);\n};\n\nmodule.exports = Uploader;\n","/**\n * Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n *\n * @file utils.js\n * @author leeight\n */\n\nvar qsModule = require(45);\nvar Q = require(44);\nvar u = require(46);\nvar helper = require(42);\nvar Queue = require(28);\nvar MimeType = require(21);\n\n/**\n * 把文件进行切片，返回切片之后的数组\n *\n * @param {Blob} file 需要切片的大文件.\n * @param {string} uploadId 从服务获取的uploadId.\n * @param {number} chunkSize 分片的大小.\n * @param {string} bucket Bucket Name.\n * @param {string} object Object Name.\n * @return {Array.<Object>}\n */\nexports.getTasks = function (file, uploadId, chunkSize, bucket, object) {\n    var leftSize = file.size;\n    var offset = 0;\n    var partNumber = 1;\n\n    var tasks = [];\n\n    while (leftSize > 0) {\n        var partSize = Math.min(leftSize, chunkSize);\n\n        tasks.push({\n            file: file,\n            uploadId: uploadId,\n            bucket: bucket,\n            object: object,\n            partNumber: partNumber,\n            partSize: partSize,\n            start: offset,\n            stop: offset + partSize - 1\n        });\n\n        leftSize -= partSize;\n        offset += partSize;\n        partNumber += 1;\n    }\n\n    return tasks;\n};\n\nexports.getAppendableTasks = function (fileSize, offset, chunkSize) {\n    var leftSize = fileSize - offset;\n    var tasks = [];\n\n    while (leftSize) {\n        var partSize = Math.min(leftSize, chunkSize);\n        tasks.push({\n            partSize: partSize,\n            start: offset,\n            stop: offset + partSize - 1\n        });\n\n        leftSize -= partSize;\n        offset += partSize;\n    }\n    return tasks;\n};\n\nexports.parseSize = function (size) {\n    if (typeof size === 'number') {\n        return size;\n    }\n\n    // mb MB Mb M\n    // kb KB kb k\n    // 100\n    var pattern = /^([\\d\\.]+)([mkg]?b?)$/i;\n    var match = pattern.exec(size);\n    if (!match) {\n        return 0;\n    }\n\n    var $1 = match[1];\n    var $2 = match[2];\n    if (/^k/i.test($2)) {\n        return $1 * 1024;\n    }\n    else if (/^m/i.test($2)) {\n        return $1 * 1024 * 1024;\n    }\n    else if (/^g/i.test($2)) {\n        return $1 * 1024 * 1024 * 1024;\n    }\n    return +$1;\n};\n\n/**\n * 判断一下浏览器是否支持 xhr2 特性，如果不支持，就 fallback 到 PostObject\n * 来上传文件\n *\n * @return {boolean}\n */\nexports.isXhr2Supported = function () {\n    // https://github.com/Modernizr/Modernizr/blob/f839e2579da2c6331eaad922ae5cd691aac7ab62/feature-detects/network/xhr2.js\n    return 'XMLHttpRequest' in window && 'withCredentials' in new XMLHttpRequest();\n};\n\nexports.isAppendable = function (headers) {\n    return headers['x-bce-object-type'] === 'Appendable';\n};\n\nexports.delay = function (ms) {\n    var deferred = Q.defer();\n    setTimeout(function () {\n        deferred.resolve();\n    }, ms);\n    return deferred.promise;\n};\n\n/**\n * 规范化用户的输入\n *\n * @param {string} endpoint The endpoint will be normalized\n * @return {string}\n */\nexports.normalizeEndpoint = function (endpoint) {\n    return endpoint.replace(/(\\/+)$/, '');\n};\n\nexports.getDefaultACL = function (bucket) {\n    return {\n        accessControlList: [\n            {\n                service: 'bce:bos',\n                region: '*',\n                effect: 'Allow',\n                resource: [bucket + '/*'],\n                permission: ['READ', 'WRITE']\n            }\n        ]\n    };\n};\n\n/**\n * 生成uuid\n *\n * @return {string}\n */\nexports.uuid = function () {\n    var random = (Math.random() * Math.pow(2, 32)).toString(36);\n    var timestamp = new Date().getTime();\n    return 'u-' + timestamp + '-' + random;\n};\n\n/**\n * 生成本地 localStorage 中的key，来存储 uploadId\n * localStorage[key] = uploadId\n *\n * @param {Object} option 一些可以用来计算key的参数.\n * @param {string} generator 内置的只有 default 和 md5\n * @return {Promise}\n */\nexports.generateLocalKey = function (option, generator) {\n    if (generator === 'default') {\n        return Q.resolve([\n            option.blob.name, option.blob.size,\n            option.chunkSize, option.bucket,\n            option.object\n        ].join('&'));\n    }\n    return Q.resolve(null);\n};\n\nexports.getDefaultPolicy = function (bucket) {\n    if (bucket == null) {\n        return null;\n    }\n\n    var now = new Date().getTime();\n\n    // 默认是 24小时 之后到期\n    var expiration = new Date(now + 24 * 60 * 60 * 1000);\n    var utcDateTime = helper.toUTCString(expiration);\n\n    return {\n        expiration: utcDateTime,\n        conditions: [\n            {bucket: bucket}\n        ]\n    };\n};\n\n/**\n * 根据key获取localStorage中的uploadId\n *\n * @param {string} key 需要查询的key\n * @return {string}\n */\nexports.getUploadId = function (key) {\n    return localStorage.getItem(key);\n};\n\n\n/**\n * 根据key设置localStorage中的uploadId\n *\n * @param {string} key 需要查询的key\n * @param {string} uploadId 需要设置的uploadId\n */\nexports.setUploadId = function (key, uploadId) {\n    localStorage.setItem(key, uploadId);\n};\n\n/**\n * 根据key删除localStorage中的uploadId\n *\n * @param {string} key 需要查询的key\n */\nexports.removeUploadId = function (key) {\n    localStorage.removeItem(key);\n};\n\n/**\n * 取得已上传分块的etag\n *\n * @param {number} partNumber 分片序号.\n * @param {Array} existParts 已上传完成的分片信息.\n * @return {string} 指定分片的etag\n */\nfunction getPartEtag(partNumber, existParts) {\n    var matchParts = u.filter(existParts || [], function (part) {\n        return +part.partNumber === partNumber;\n    });\n    return matchParts.length ? matchParts[0].eTag : null;\n}\n\n/**\n * 因为 listParts 会返回 partNumber 和 etag 的对应关系\n * 所以 listParts 返回的结果，给 tasks 中合适的元素设置 etag 属性，上传\n * 的时候就可以跳过这些 part\n *\n * @param {Array.<Object>} tasks 本地切分好的任务.\n * @param {Array.<Object>} parts 服务端返回的已经上传的parts.\n */\nexports.filterTasks = function (tasks, parts) {\n    u.each(tasks, function (task) {\n        var partNumber = task.partNumber;\n        var etag = getPartEtag(partNumber, parts);\n        if (etag) {\n            task.etag = etag;\n        }\n    });\n};\n\n/**\n * 把用户输入的配置转化成 html5 和 flash 可以接收的内容.\n *\n * @param {string|Array} accept 支持数组和字符串的配置\n * @return {string}\n */\nexports.expandAccept = function (accept) {\n    var exts = [];\n\n    if (u.isArray(accept)) {\n        // Flash要求的格式\n        u.each(accept, function (item) {\n            if (item.extensions) {\n                exts.push.apply(exts, item.extensions.split(','));\n            }\n        });\n    }\n    else if (u.isString(accept)) {\n        exts = accept.split(',');\n    }\n\n    // 为了保证兼容性，把 mimeTypes 和 exts 都返回回去\n    exts = u.map(exts, function (ext) {\n        return /^\\./.test(ext) ? ext : ('.' + ext);\n    });\n\n    return exts.join(',');\n};\n\nexports.extToMimeType = function (exts) {\n    var mimeTypes = u.map(exts.split(','), function (ext) {\n        if (ext.indexOf('/') !== -1) {\n            return ext;\n        }\n        return MimeType.guess(ext);\n    });\n\n    return mimeTypes.join(',');\n};\n\nexports.expandAcceptToArray = function (accept) {\n    if (!accept || u.isArray(accept)) {\n        return accept;\n    }\n\n    if (u.isString(accept)) {\n        return [\n            {title: 'All files', extensions: accept}\n        ];\n    }\n\n    return [];\n};\n\n/**\n * 转化一下 bos url 的格式\n * http://bj.bcebos.com/v1/${bucket}/${object} -> http://${bucket}.bj.bcebos.com/v1/${object}\n *\n * @param {string} url 需要转化的URL.\n * @return {string}\n */\nexports.transformUrl = function (url) {\n    var pattern = /(https?:)\\/\\/([^\\/]+)\\/([^\\/]+)\\/([^\\/]+)/;\n    return url.replace(pattern, function (_, protocol, host, $3, $4) {\n        if (/^v\\d$/.test($3)) {\n            // /v1/${bucket}/...\n            return protocol + '//' + $4 + '.' + host + '/' + $3;\n        }\n        // /${bucket}/...\n        return protocol + '//' + $3 + '.' + host + '/' + $4;\n    });\n};\n\nexports.isBlob = function (body) {\n    var blobCtor = null;\n\n    if (typeof Blob !== 'undefined') {\n        // Chrome Blob === 'function'\n        // Safari Blob === 'undefined'\n        blobCtor = Blob;\n    }\n    else if (typeof mOxie !== 'undefined' && u.isFunction(mOxie.Blob)) {\n        blobCtor = mOxie.Blob;\n    }\n    else {\n        return false;\n    }\n\n    return body instanceof blobCtor;\n};\n\nexports.now = function () {\n    return new Date().getTime();\n};\n\nexports.toDHMS = function (seconds) {\n    var days = 0;\n    var hours = 0;\n    var minutes = 0;\n\n    if (seconds >= 60) {\n        minutes = ~~(seconds / 60);\n        seconds = seconds - minutes * 60;\n    }\n\n    if (minutes >= 60) {\n        hours = ~~(minutes / 60);\n        minutes = minutes - hours * 60;\n    }\n\n    if (hours >= 24) {\n        days = ~~(hours / 24);\n        hours = hours - days * 24;\n    }\n\n    return {DD: days, HH: hours, MM: minutes, SS: seconds};\n};\n\nfunction parseHost(url) {\n    var match = /^\\w+:\\/\\/([^\\/]+)/.exec(url);\n    return match && match[1];\n}\n\nexports.fixXhr = function (options, isBos) {\n    return function (httpMethod, resource, args, config) {\n        var client = this;\n        var endpointHost = parseHost(config.endpoint);\n\n        // x-bce-date 和 Date 二选一，是必须的\n        // 但是 Flash 无法设置 Date，因此必须设置 x-bce-date\n        args.headers['x-bce-date'] = helper.toUTCString(new Date());\n        args.headers.host = endpointHost;\n\n        // Flash 的缓存貌似比较厉害，强制请求新的\n        // XXX 好像服务器端不会把 .stamp 这个参数加入到签名的计算逻辑里面去\n        args.params['.stamp'] = new Date().getTime();\n\n        // 只有 PUT 才会触发 progress 事件\n        var originalHttpMethod = httpMethod;\n\n        if (httpMethod === 'PUT') {\n            // PutObject PutParts 都可以用 POST 协议，而且 Flash 也只能用 POST 协议\n            httpMethod = 'POST';\n        }\n\n        var xhrUri;\n        var xhrMethod = httpMethod;\n        var xhrBody = args.body;\n        if (httpMethod === 'HEAD') {\n            // 因为 Flash 的 URLRequest 只能发送 GET 和 POST 请求\n            // getObjectMeta需要用HEAD请求，但是 Flash 无法发起这种请求\n            // 所需需要用 relay 中转一下\n            // XXX 因为 bucket 不可能是 private，否则 crossdomain.xml 是无法读取的\n            // 所以这个接口请求的时候，可以不需要 authorization 字段\n            var relayServer = exports.normalizeEndpoint(options.bos_relay_server);\n            xhrUri = relayServer + '/' + endpointHost + resource;\n\n            args.params.httpMethod = httpMethod;\n\n            xhrMethod = 'POST';\n        }\n        else if (isBos === true) {\n            xhrUri = exports.transformUrl(config.endpoint + resource);\n            resource = xhrUri.replace(/^\\w+:\\/\\/[^\\/]+\\//, '/');\n            args.headers.host = parseHost(xhrUri);\n        }\n        else {\n            xhrUri = config.endpoint + resource;\n        }\n\n        if (xhrMethod === 'POST' && !xhrBody) {\n            // 必须要有 BODY 才能是 POST，否则你设置了也没有\n            // 而且必须是 POST 才可以设置自定义的header，GET不行\n            xhrBody = '{\"FORCE_POST\": true}';\n        }\n\n        var deferred = Q.defer();\n\n        var xhr = new mOxie.XMLHttpRequest();\n\n        xhr.onload = function () {\n            var response = null;\n            try {\n                response = JSON.parse(xhr.response || '{}');\n                response.location = xhrUri;\n            }\n            catch (ex) {\n                response = {\n                    location: xhrUri\n                };\n            }\n\n            if (xhr.status >= 200 && xhr.status < 300) {\n                if (httpMethod === 'HEAD') {\n                    deferred.resolve(response);\n                }\n                else {\n                    deferred.resolve({\n                        http_headers: {},\n                        body: response\n                    });\n                }\n            }\n            else {\n                deferred.reject({\n                    status_code: xhr.status,\n                    message: response.message || '',\n                    code: response.code || '',\n                    request_id: response.requestId || ''\n                });\n            }\n        };\n\n        xhr.onerror = function (error) {\n            deferred.reject(error);\n        };\n\n        if (xhr.upload) {\n            // FIXME(分片上传的逻辑和xxx的逻辑不一样)\n            xhr.upload.onprogress = function (e) {\n                if (originalHttpMethod === 'PUT') {\n                    // POST, HEAD, GET 之类的不需要触发 progress 事件\n                    // 否则导致页面的逻辑混乱\n                    e.lengthComputable = true;\n\n                    var httpContext = {\n                        httpMethod: originalHttpMethod,\n                        resource: resource,\n                        args: args,\n                        config: config,\n                        xhr: xhr\n                    };\n\n                    client.emit('progress', e, httpContext);\n                }\n            };\n        }\n\n        var promise = client.createSignature(client.config.credentials,\n            httpMethod, resource, args.params, args.headers);\n        promise.then(function (authorization, xbceDate) {\n            if (authorization) {\n                args.headers.authorization = authorization;\n            }\n\n            if (xbceDate) {\n                args.headers['x-bce-date'] = xbceDate;\n            }\n\n            var qs = qsModule.stringify(args.params);\n            if (qs) {\n                xhrUri += '?' + qs;\n            }\n\n            xhr.open(xhrMethod, xhrUri, true);\n\n            for (var key in args.headers) {\n                if (!args.headers.hasOwnProperty(key)\n                    || /(host|content\\-length)/i.test(key)) {\n                    continue;\n                }\n                var value = args.headers[key];\n                xhr.setRequestHeader(key, value);\n            }\n\n            xhr.send(xhrBody, {\n                runtime_order: 'flash',\n                swf_url: options.flash_swf_url\n            });\n        })[\n        \"catch\"](function (error) {\n            deferred.reject(error);\n        });\n\n        return deferred.promise;\n    };\n};\n\n\nexports.eachLimit = function (tasks, taskParallel, executer, done) {\n    var runningCount = 0;\n    var aborted = false;\n    var fin = false;      // done 只能被调用一次.\n    var queue = new Queue(tasks);\n\n    function infiniteLoop() {\n        var task = queue.dequeue();\n        if (!task) {\n            return;\n        }\n\n        runningCount++;\n        executer(task, function (error) {\n            runningCount--;\n\n            if (error) {\n                // 一旦有报错，终止运行\n                aborted = true;\n                fin = true;\n                done(error);\n            }\n            else {\n                if (!queue.isEmpty() && !aborted) {\n                    // 队列还有内容\n                    setTimeout(infiniteLoop, 0);\n                }\n                else if (runningCount <= 0) {\n                    // 队列空了，而且没有运行中的任务了\n                    if (!fin) {\n                        fin = true;\n                        done();\n                    }\n                }\n            }\n        });\n    }\n\n    taskParallel = Math.min(taskParallel, queue.size());\n    for (var i = 0; i < taskParallel; i++) {\n        infiniteLoop();\n    }\n};\n\nexports.inherits = function (ChildCtor, ParentCtor) {\n    return require(47).inherits(ChildCtor, ParentCtor);\n};\n\nexports.guessContentType = function (file, opt_ignoreCharset) {\n    var contentType = file.type;\n    if (!contentType) {\n        var object = file.name;\n        var ext = object.split(/\\./g).pop();\n        contentType = MimeType.guess(ext);\n    }\n\n    // Firefox在POST的时候，Content-Type 一定会有Charset的，因此\n    // 这里不管3721，都加上.\n    if (!opt_ignoreCharset && !/charset=/.test(contentType)) {\n        contentType += '; charset=UTF-8';\n    }\n\n    return contentType;\n};\n","/**\n * @file vendor/Buffer.js\n * @author leeight\n */\n\n/**\n * Buffer\n *\n * @class\n */\nfunction Buffer() {\n}\n\nBuffer.byteLength = function (data) {\n    // http://stackoverflow.com/questions/5515869/string-length-in-bytes-in-javascript\n    var m = encodeURIComponent(data).match(/%[89ABab]/g);\n    return data.length + (m ? m.length : 0);\n};\n\nmodule.exports = Buffer;\n\n\n\n\n\n\n\n\n\n\n","/**\n * @file Promise.js\n * @author ??\n */\n\n(function (root) {\n\n    // Store setTimeout reference so promise-polyfill will be unaffected by\n    // other code modifying setTimeout (like sinon.useFakeTimers())\n    var setTimeoutFunc = setTimeout;\n\n    function noop() {\n    }\n\n    // Polyfill for Function.prototype.bind\n    function bind(fn, thisArg) {\n        return function () {\n            fn.apply(thisArg, arguments);\n        };\n    }\n\n    /**\n     * Promise\n     *\n     * @param {Function} fn The executor.\n     * @class\n     */\n    function Promise(fn) {\n        if (typeof this !== 'object') {\n            throw new TypeError('Promises must be constructed via new');\n        }\n\n        if (typeof fn !== 'function') {\n            throw new TypeError('not a function');\n        }\n\n        this._state = 0;\n        this._handled = false;\n        this._value = undefined;\n        this._deferreds = [];\n\n        doResolve(fn, this);\n    }\n\n    function handle(self, deferred) {\n        while (self._state === 3) {\n            self = self._value;\n        }\n        if (self._state === 0) {\n            self._deferreds.push(deferred);\n            return;\n        }\n\n        self._handled = true;\n        Promise._immediateFn(function () {\n            var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n            if (cb === null) {\n                (self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n                return;\n            }\n\n            var ret;\n            try {\n                ret = cb(self._value);\n            }\n            catch (e) {\n                reject(deferred.promise, e);\n                return;\n            }\n            resolve(deferred.promise, ret);\n        });\n    }\n\n    function resolve(self, newValue) {\n        try {\n            // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n            if (newValue === self) {\n                throw new TypeError('A promise cannot be resolved with itself.');\n            }\n\n            if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {\n                var then = newValue.then;\n                if (newValue instanceof Promise) {\n                    self._state = 3;\n                    self._value = newValue;\n                    finale(self);\n                    return;\n                }\n                else if (typeof then === 'function') {\n                    doResolve(bind(then, newValue), self);\n                    return;\n                }\n            }\n\n            self._state = 1;\n            self._value = newValue;\n            finale(self);\n        }\n        catch (e) {\n            reject(self, e);\n        }\n    }\n\n    function reject(self, newValue) {\n        self._state = 2;\n        self._value = newValue;\n        finale(self);\n    }\n\n    function finale(self) {\n        if (self._state === 2 && self._deferreds.length === 0) {\n            Promise._immediateFn(function () {\n                if (!self._handled) {\n                    Promise._unhandledRejectionFn(self._value);\n                }\n\n            });\n        }\n\n        for (var i = 0, len = self._deferreds.length; i < len; i++) {\n            handle(self, self._deferreds[i]);\n        }\n        self._deferreds = null;\n    }\n\n    /**\n     * Handler\n     *\n     * @class\n     * @param {*} onFulfilled The onFulfilled.\n     * @param {*} onRejected The onRejected.\n     * @param {*} promise The promise.\n     */\n    function Handler(onFulfilled, onRejected, promise) {\n        this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n        this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n        this.promise = promise;\n    }\n\n    /**\n     * Take a potentially misbehaving resolver function and make sure\n     * onFulfilled and onRejected are only called once.\n     *\n     * Makes no guarantees about asynchrony.\n     *\n     * @param {Function} fn The fn.\n     * @param {*} self The context.\n     */\n    function doResolve(fn, self) {\n        var done = false;\n        try {\n            fn(function (value) {\n                if (done) {\n                    return;\n                }\n\n                done = true;\n                resolve(self, value);\n            }, function (reason) {\n                if (done) {\n                    return;\n                }\n\n                done = true;\n                reject(self, reason);\n            });\n        }\n        catch (ex) {\n            if (done) {\n                return;\n            }\n\n            done = true;\n            reject(self, ex);\n        }\n    }\n\n    Promise.prototype[\"catch\"] = function (onRejected) {   // eslint-disable-line\n        return this.then(null, onRejected);\n    };\n\n    Promise.prototype.then = function (onFulfilled, onRejected) {   // eslint-disable-line\n        var prom = new (this.constructor)(noop);\n\n        handle(this, new Handler(onFulfilled, onRejected, prom));\n        return prom;\n    };\n\n    Promise.all = function (arr) {\n        var args = Array.prototype.slice.call(arr);\n\n        return new Promise(function (resolve, reject) {\n            if (args.length === 0) {\n                return resolve([]);\n            }\n\n            var remaining = args.length;\n\n            function res(i, val) {\n                try {\n                    if (val && (typeof val === 'object' || typeof val === 'function')) {\n                        var then = val.then;\n                        if (typeof then === 'function') {\n                            then.call(val, function (val) {\n                                res(i, val);\n                            }, reject);\n                            return;\n                        }\n                    }\n\n                    args[i] = val;\n                    if (--remaining === 0) {\n                        resolve(args);\n                    }\n\n                }\n                catch (ex) {\n                    reject(ex);\n                }\n            }\n\n            for (var i = 0; i < args.length; i++) {\n                res(i, args[i]);\n            }\n        });\n    };\n\n    Promise.resolve = function (value) {\n        if (value && typeof value === 'object' && value.constructor === Promise) {\n            return value;\n        }\n\n        return new Promise(function (resolve) {\n            resolve(value);\n        });\n    };\n\n    Promise.reject = function (value) {\n        return new Promise(function (resolve, reject) {\n            reject(value);\n        });\n    };\n\n    Promise.race = function (values) {\n        return new Promise(function (resolve, reject) {\n            for (var i = 0, len = values.length; i < len; i++) {\n                values[i].then(resolve, reject);\n            }\n        });\n    };\n\n    // Use polyfill for setImmediate for performance gains\n    Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) {\n        setImmediate(fn);\n    }) || function (fn) {\n        setTimeoutFunc(fn, 0);\n    };\n\n    Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n        if (typeof console !== 'undefined' && console) {\n            console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n        }\n\n    };\n\n    /**\n     * Set the immediate function to execute callbacks\n     *\n     * @param {Function} fn Function to execute\n     * @deprecated\n     */\n    Promise._setImmediateFn = function _setImmediateFn(fn) {\n        Promise._immediateFn = fn;\n    };\n\n    /**\n     * Change the function to execute on unhandled rejection\n     *\n     * @param {Function} fn Function to execute on unhandled rejection\n     * @deprecated\n     */\n    Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {\n        Promise._unhandledRejectionFn = fn;\n    };\n\n    if (typeof module !== 'undefined' && module.exports) {\n        module.exports = Promise;\n    }\n    else if (!root.Promise) {\n        root.Promise = Promise;\n    }\n\n})(this);\n","/**\n * @file vendor/async.js\n * @author leeight\n */\n\nexports.mapLimit = require(2);\n","/**\n * @file core.js\n * @author ???\n */\n\n/**\n * Local polyfil of Object.create\n */\nvar create = Object.create || (function () {\n    function F() {    // eslint-disable-line\n    }\n\n    return function (obj) {\n        var subtype;\n\n        F.prototype = obj;\n\n        subtype = new F();\n\n        F.prototype = null;\n\n        return subtype;\n    };\n}());\n\n/**\n * CryptoJS namespace.\n */\nvar C = {};\n\n/**\n * Algorithm namespace.\n */\nvar C_algo = C.algo = {};\n\n/**\n * Library namespace.\n */\nvar C_lib = C.lib = {};\n\n/**\n  * Base object for prototypal inheritance.\n  */\nvar Base = C_lib.Base = (function () {\n\n    return {\n\n        /**\n          * Creates a new object that inherits from this object.\n          *\n          * @param {Object} overrides Properties to copy into the new object.\n          *\n          * @return {Object} The new object.\n          *\n          * @static\n          *\n          * @example\n          *\n          *     var MyType = CryptoJS.lib.Base.extend({\n          *         field: 'value',\n          *\n          *         method: function () {\n          *         }\n          *     });\n          */\n        extend: function (overrides) {\n            // Spawn\n            var subtype = create(this);\n\n            // Augment\n            if (overrides) {\n                subtype.mixIn(overrides);\n            }\n\n            // Create default initializer\n            if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {\n                subtype.init = function () {\n                    subtype.$super.init.apply(this, arguments);\n                };\n            }\n\n            // Initializer's prototype is the subtype object\n            subtype.init.prototype = subtype;\n\n            // Reference supertype\n            subtype.$super = this;\n\n            return subtype;\n        },\n\n        /**\n          * Extends this object and runs the init method.\n          * Arguments to create() will be passed to init().\n          *\n          * @return {Object} The new object.\n          *\n          * @static\n          *\n          * @example\n          *\n          *     var instance = MyType.create();\n          */\n        create: function () {\n            var instance = this.extend();\n            instance.init.apply(instance, arguments);\n\n            return instance;\n        },\n\n        /**\n          * Initializes a newly created object.\n          * Override this method to add some logic when your objects are created.\n          *\n          * @example\n          *\n          *     var MyType = CryptoJS.lib.Base.extend({\n          *         init: function () {\n          *             // ...\n          *         }\n          *     });\n          */\n        init: function () {},\n\n        /**\n          * Copies properties into this object.\n          *\n          * @param {Object} properties The properties to mix in.\n          *\n          * @example\n          *\n          *     MyType.mixIn({\n          *         field: 'value'\n          *     });\n          */\n        mixIn: function (properties) {\n            for (var propertyName in properties) {\n                if (properties.hasOwnProperty(propertyName)) {\n                    this[propertyName] = properties[propertyName];\n                }\n\n            }\n\n            // IE won't copy toString using the loop above\n            if (properties.hasOwnProperty('toString')) {\n                this.toString = properties.toString;\n            }\n\n        },\n\n        /**\n          * Creates a copy of this object.\n          *\n          * @return {Object} The clone.\n          *\n          * @example\n          *\n          *     var clone = instance.clone();\n          */\n        clone: function () {\n            return this.init.prototype.extend(this);\n        }\n    };\n}());\n\n/**\n  * An array of 32-bit words.\n  *\n  * @property {Array} words The array of 32-bit words.\n  * @property {number} sigBytes The number of significant bytes in this word array.\n  */\nvar WordArray = C_lib.WordArray = Base.extend({\n\n    /**\n      * Initializes a newly created word array.\n      *\n      * @param {Array} words (Optional) An array of 32-bit words.\n      * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n      *\n      * @example\n      *\n      *     var wordArray = CryptoJS.lib.WordArray.create();\n      *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n      *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n      */\n    init: function (words, sigBytes) {\n        words = this.words = words || [];\n\n        if (sigBytes != undefined) {    // eslint-disable-line\n            this.sigBytes = sigBytes;\n        }\n        else {\n            this.sigBytes = words.length * 4;\n        }\n    },\n\n    /**\n      * Converts this word array to a string.\n      *\n      * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n      *\n      * @return {string} The stringified word array.\n      *\n      * @example\n      *\n      *     var string = wordArray + '';\n      *     var string = wordArray.toString();\n      *     var string = wordArray.toString(CryptoJS.enc.Utf8);\n      */\n    toString: function (encoder) {\n        return (encoder || Hex).stringify(this);    // eslint-disable-line\n    },\n\n    /**\n      * Concatenates a word array to this word array.\n      *\n      * @param {WordArray} wordArray The word array to append.\n      *\n      * @return {WordArray} This word array.\n      *\n      * @example\n      *\n      *     wordArray1.concat(wordArray2);\n      */\n    concat: function (wordArray) {\n        // Shortcuts\n        var thisWords = this.words;\n        var thatWords = wordArray.words;\n        var thisSigBytes = this.sigBytes;\n        var thatSigBytes = wordArray.sigBytes;\n\n        // Clamp excess bits\n        this.clamp();\n\n\n        var i;\n\n        // Concat\n        if (thisSigBytes % 4) {\n            // Copy one byte at a time\n            for (i = 0; i < thatSigBytes; i++) {\n                var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n                thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\n            }\n        }\n        else {\n            // Copy one word at a time\n            for (i = 0; i < thatSigBytes; i += 4) {\n                thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];\n            }\n        }\n        this.sigBytes += thatSigBytes;\n\n        // Chainable\n        return this;\n    },\n\n    /**\n      * Removes insignificant bits.\n      *\n      * @example\n      *\n      *     wordArray.clamp();\n      */\n    clamp: function () {\n        // Shortcuts\n        var words = this.words;\n        var sigBytes = this.sigBytes;\n\n        // Clamp\n        words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\n        words.length = Math.ceil(sigBytes / 4);\n    },\n\n    /**\n      * Creates a copy of this word array.\n      *\n      * @return {WordArray} The clone.\n      *\n      * @example\n      *\n      *     var clone = wordArray.clone();\n      */\n    clone: function () {\n        var clone = Base.clone.call(this);\n        clone.words = this.words.slice(0);\n\n        return clone;\n    },\n\n    /**\n      * Creates a word array filled with random bytes.\n      *\n      * @param {number} nBytes The number of random bytes to generate.\n      *\n      * @return {WordArray} The random word array.\n      *\n      * @static\n      *\n      * @example\n      *\n      *     var wordArray = CryptoJS.lib.WordArray.random(16);\n      */\n    random: function (nBytes) {\n        var words = [];\n\n        var r = function (m_w) {\n            var m_z = 0x3ade68b1;\n            var mask = 0xffffffff;\n\n            return function () {\n                m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;\n                m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;\n                var result = ((m_z << 0x10) + m_w) & mask;\n                result /= 0x100000000;\n                result += 0.5;\n                return result * (Math.random() > .5 ? 1 : -1);\n            };\n        };\n\n        for (var i = 0, rcache; i < nBytes; i += 4) {\n            var _r = r((rcache || Math.random()) * 0x100000000);\n\n            rcache = _r() * 0x3ade67b7;\n            words.push((_r() * 0x100000000) | 0);\n        }\n\n        return new WordArray.init(words, nBytes); // eslint-disable-line\n    }\n});\n\n/**\n  * Encoder namespace.\n  */\nvar C_enc = C.enc = {};\n\n/**\n  * Hex encoding strategy.\n  */\nvar Hex = C_enc.Hex = {\n\n    /**\n      * Converts a word array to a hex string.\n      *\n      * @param {WordArray} wordArray The word array.\n      *\n      * @return {string} The hex string.\n      *\n      * @static\n      *\n      * @example\n      *\n      *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n      */\n    stringify: function (wordArray) {\n        // Shortcuts\n        var words = wordArray.words;\n        var sigBytes = wordArray.sigBytes;\n\n        // Convert\n        var hexChars = [];\n        for (var i = 0; i < sigBytes; i++) {\n            var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n            hexChars.push((bite >>> 4).toString(16));\n            hexChars.push((bite & 0x0f).toString(16));\n        }\n\n        return hexChars.join('');\n    },\n\n    /**\n      * Converts a hex string to a word array.\n      *\n      * @param {string} hexStr The hex string.\n      *\n      * @return {WordArray} The word array.\n      *\n      * @static\n      *\n      * @example\n      *\n      *     var wordArray = CryptoJS.enc.Hex.parse(hexString);\n      */\n    parse: function (hexStr) {\n        // Shortcut\n        var hexStrLength = hexStr.length;\n\n        // Convert\n        var words = [];\n        for (var i = 0; i < hexStrLength; i += 2) {\n            words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\n        }\n\n        return new WordArray.init(words, hexStrLength / 2);   // eslint-disable-line\n    }\n};\n\n/**\n  * Latin1 encoding strategy.\n  */\nvar Latin1 = C_enc.Latin1 = {\n\n    /**\n      * Converts a word array to a Latin1 string.\n      *\n      * @param {WordArray} wordArray The word array.\n      *\n      * @return {string} The Latin1 string.\n      *\n      * @static\n      *\n      * @example\n      *\n      *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n      */\n    stringify: function (wordArray) {\n        // Shortcuts\n        var words = wordArray.words;\n        var sigBytes = wordArray.sigBytes;\n\n        // Convert\n        var latin1Chars = [];\n        for (var i = 0; i < sigBytes; i++) {\n            var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n            latin1Chars.push(String.fromCharCode(bite));\n        }\n\n        return latin1Chars.join('');\n    },\n\n    /**\n      * Converts a Latin1 string to a word array.\n      *\n      * @param {string} latin1Str The Latin1 string.\n      *\n      * @return {WordArray} The word array.\n      *\n      * @static\n      *\n      * @example\n      *\n      *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n      */\n    parse: function (latin1Str) {\n        // Shortcut\n        var latin1StrLength = latin1Str.length;\n\n        // Convert\n        var words = [];\n        for (var i = 0; i < latin1StrLength; i++) {\n            words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\n        }\n\n        return new WordArray.init(words, latin1StrLength);    // eslint-disable-line\n    }\n};\n\n/**\n  * UTF-8 encoding strategy.\n  */\nvar Utf8 = C_enc.Utf8 = {\n\n    /**\n      * Converts a word array to a UTF-8 string.\n      *\n      * @param {WordArray} wordArray The word array.\n      *\n      * @return {string} The UTF-8 string.\n      *\n      * @static\n      *\n      * @example\n      *\n      *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n      */\n    stringify: function (wordArray) {\n        try {\n            return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n        }\n        catch (e) {\n            throw new Error('Malformed UTF-8 data');\n        }\n    },\n\n    /**\n      * Converts a UTF-8 string to a word array.\n      *\n      * @param {string} utf8Str The UTF-8 string.\n      *\n      * @return {WordArray} The word array.\n      *\n      * @static\n      *\n      * @example\n      *\n      *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n      */\n    parse: function (utf8Str) {\n        return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n    }\n};\n\n/**\n  * Abstract buffered block algorithm template.\n  *\n  * The property blockSize must be implemented in a concrete subtype.\n  *\n  * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\n  */\nvar BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\n\n    /**\n      * Resets this block algorithm's data buffer to its initial state.\n      *\n      * @example\n      *\n      *     bufferedBlockAlgorithm.reset();\n      */\n    reset: function () {\n        // Initial values\n        this._data = new WordArray.init();    // eslint-disable-line\n        this._nDataBytes = 0;\n    },\n\n    /**\n      * Adds new data to this block algorithm's buffer.\n      *\n      * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\n      *\n      * @example\n      *\n      *     bufferedBlockAlgorithm._append('data');\n      *     bufferedBlockAlgorithm._append(wordArray);\n      */\n    _append: function (data) {\n        // Convert string to WordArray, else assume WordArray already\n        if (typeof data === 'string') {\n            data = Utf8.parse(data);\n        }\n\n        // Append\n        this._data.concat(data);\n        this._nDataBytes += data.sigBytes;\n    },\n\n    /**\n      * Processes available data blocks.\n      *\n      * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n      *\n      * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n      *\n      * @return {WordArray} The processed data.\n      *\n      * @example\n      *\n      *     var processedData = bufferedBlockAlgorithm._process();\n      *     var processedData = bufferedBlockAlgorithm._process(!!'flush');\n      */\n    _process: function (doFlush) {\n        // Shortcuts\n        var data = this._data;\n        var dataWords = data.words;\n        var dataSigBytes = data.sigBytes;\n        var blockSize = this.blockSize;\n        var blockSizeBytes = blockSize * 4;\n\n        // Count blocks ready\n        var nBlocksReady = dataSigBytes / blockSizeBytes;\n        if (doFlush) {\n            // Round up to include partial blocks\n            nBlocksReady = Math.ceil(nBlocksReady);\n        }\n        else {\n            // Round down to include only full blocks,\n            // less the number of blocks that must remain in the buffer\n            nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n        }\n\n        // Count words ready\n        var nWordsReady = nBlocksReady * blockSize;\n\n        // Count bytes ready\n        var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\n        // Process blocks\n        if (nWordsReady) {\n            for (var offset = 0; offset < nWordsReady; offset += blockSize) {\n                // Perform concrete-algorithm logic\n                this._doProcessBlock(dataWords, offset);\n            }\n\n            // Remove processed words\n            var processedWords = dataWords.splice(0, nWordsReady);\n            data.sigBytes -= nBytesReady;\n        }\n\n        // Return processed words\n        return new WordArray.init(processedWords, nBytesReady);   // eslint-disable-line\n    },\n\n    /**\n      * Creates a copy of this object.\n      *\n      * @return {Object} The clone.\n      *\n      * @example\n      *\n      *     var clone = bufferedBlockAlgorithm.clone();\n      */\n    clone: function () {\n        var clone = Base.clone.call(this);\n        clone._data = this._data.clone();\n\n        return clone;\n    },\n\n    _minBufferSize: 0\n});\n\n/**\n  * Abstract hasher template.\n  *\n  * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n  */\nC_lib.Hasher = BufferedBlockAlgorithm.extend({\n\n    /**\n      * Configuration options.\n      */\n    cfg: Base.extend(),\n\n    /**\n      * Initializes a newly created hasher.\n      *\n      * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\n      *\n      * @example\n      *\n      *     var hasher = CryptoJS.algo.SHA256.create();\n      */\n    init: function (cfg) {\n        // Apply config defaults\n        this.cfg = this.cfg.extend(cfg);\n\n        // Set initial values\n        this.reset();\n    },\n\n    /**\n      * Resets this hasher to its initial state.\n      *\n      * @example\n      *\n      *     hasher.reset();\n      */\n    reset: function () {\n        // Reset data buffer\n        BufferedBlockAlgorithm.reset.call(this);\n\n        // Perform concrete-hasher logic\n        this._doReset();\n    },\n\n    /**\n      * Updates this hasher with a message.\n      *\n      * @param {WordArray|string} messageUpdate The message to append.\n      *\n      * @return {Hasher} This hasher.\n      *\n      * @example\n      *\n      *     hasher.update('message');\n      *     hasher.update(wordArray);\n      */\n    update: function (messageUpdate) {\n        // Append\n        this._append(messageUpdate);\n\n        // Update the hash\n        this._process();\n\n        // Chainable\n        return this;\n    },\n\n    /**\n      * Finalizes the hash computation.\n      * Note that the finalize operation is effectively a destructive, read-once operation.\n      *\n      * @param {WordArray|string} messageUpdate (Optional) A final message update.\n      *\n      * @return {WordArray} The hash.\n      *\n      * @example\n      *\n      *     var hash = hasher.finalize();\n      *     var hash = hasher.finalize('message');\n      *     var hash = hasher.finalize(wordArray);\n      */\n    finalize: function (messageUpdate) {\n        // Final message update\n        if (messageUpdate) {\n            this._append(messageUpdate);\n        }\n\n        // Perform concrete-hasher logic\n        var hash = this._doFinalize();\n\n        return hash;\n    },\n\n    blockSize: 512 / 32,\n\n    /**\n      * Creates a shortcut function to a hasher's object interface.\n      *\n      * @param {Hasher} hasher The hasher to create a helper for.\n      *\n      * @return {Function} The shortcut function.\n      *\n      * @static\n      *\n      * @example\n      *\n      *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n      */\n    _createHelper: function (hasher) {\n        return function (message, cfg) {\n            return new hasher.init(cfg).finalize(message);    // eslint-disable-line\n        };\n    },\n\n    /**\n      * Creates a shortcut function to the HMAC's object interface.\n      *\n      * @param {Hasher} hasher The hasher to use in this HMAC helper.\n      *\n      * @return {Function} The shortcut function.\n      *\n      * @static\n      *\n      * @example\n      *\n      *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n      */\n    _createHmacHelper: function (hasher) {\n        return function (message, key) {\n            return new C_algo.HMAC.init(hasher, key).finalize(message);   // eslint-disable-line\n        };\n    }\n});\n\nmodule.exports = C;\n","/**\n * @file hmac-sha256.js\n * @author ???\n */\nrequire(39);\nrequire(38);\nvar CryptoJS = require(36);\n\nmodule.exports = CryptoJS.HmacSHA256;\n","/**\n * @file hmac.js\n * @author ???\n */\n\nvar CryptoJS = require(36);\n\n// Shortcuts\nvar C = CryptoJS;\nvar C_lib = C.lib;\nvar Base = C_lib.Base;\nvar C_enc = C.enc;\nvar Utf8 = C_enc.Utf8;\nvar C_algo = C.algo;\n\n/**\n * HMAC algorithm.\n */\nC_algo.HMAC = Base.extend({\n\n    /**\n     * Initializes a newly created HMAC.\n     *\n     * @param {Hasher} hasher The hash algorithm to use.\n     * @param {WordArray|string} key The secret key.\n     *\n     * @example\n     *\n     *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);\n     */\n    init: function (hasher, key) {\n        // Init hasher\n        hasher = this._hasher = new hasher.init();    // eslint-disable-line\n\n        // Convert string to WordArray, else assume WordArray already\n        if (typeof key === 'string') {\n            key = Utf8.parse(key);\n        }\n\n        // Shortcuts\n        var hasherBlockSize = hasher.blockSize;\n        var hasherBlockSizeBytes = hasherBlockSize * 4;\n\n        // Allow arbitrary length keys\n        if (key.sigBytes > hasherBlockSizeBytes) {\n            key = hasher.finalize(key);\n        }\n\n        // Clamp excess bits\n        key.clamp();\n\n        // Clone key for inner and outer pads\n        var oKey = this._oKey = key.clone();\n        var iKey = this._iKey = key.clone();\n\n        // Shortcuts\n        var oKeyWords = oKey.words;\n        var iKeyWords = iKey.words;\n\n        // XOR keys with pad constants\n        for (var i = 0; i < hasherBlockSize; i++) {\n            oKeyWords[i] ^= 0x5c5c5c5c;\n            iKeyWords[i] ^= 0x36363636;\n        }\n        oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;\n\n        // Set initial values\n        this.reset();\n    },\n\n    /**\n     * Resets this HMAC to its initial state.\n     *\n     * @example\n     *\n     *     hmacHasher.reset();\n     */\n    reset: function () {\n        // Shortcut\n        var hasher = this._hasher;\n\n        // Reset\n        hasher.reset();\n        hasher.update(this._iKey);\n    },\n\n    /**\n     * Updates this HMAC with a message.\n     *\n     * @param {WordArray|string} messageUpdate The message to append.\n     *\n     * @return {HMAC} This HMAC instance.\n     *\n     * @example\n     *\n     *     hmacHasher.update('message');\n     *     hmacHasher.update(wordArray);\n     */\n    update: function (messageUpdate) {\n        this._hasher.update(messageUpdate);\n\n        // Chainable\n        return this;\n    },\n\n    /**\n     * Finalizes the HMAC computation.\n     * Note that the finalize operation is effectively a destructive, read-once operation.\n     *\n     * @param {WordArray|string} messageUpdate (Optional) A final message update.\n     *\n     * @return {WordArray} The HMAC.\n     *\n     * @example\n     *\n     *     var hmac = hmacHasher.finalize();\n     *     var hmac = hmacHasher.finalize('message');\n     *     var hmac = hmacHasher.finalize(wordArray);\n     */\n    finalize: function (messageUpdate) {\n        // Shortcut\n        var hasher = this._hasher;\n\n        // Compute HMAC\n        var innerHash = hasher.finalize(messageUpdate);\n        hasher.reset();\n        var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));\n\n        return hmac;\n    }\n});\n","/**\n * @file sha256.js\n * @author ???\n */\nvar CryptoJS = require(36);\n\n    // Shortcuts\nvar C = CryptoJS;\nvar C_lib = C.lib;\nvar WordArray = C_lib.WordArray;\nvar Hasher = C_lib.Hasher;\nvar C_algo = C.algo;\n\n// Initialization and round constants tables\nvar H = [];\nvar K = [];\n\n// Compute constants\n(function () {\n    function isPrime(n) {\n        var sqrtN = Math.sqrt(n);\n        for (var factor = 2; factor <= sqrtN; factor++) {\n            if (!(n % factor)) {\n                return false;\n            }\n\n        }\n\n        return true;\n    }\n\n    function getFractionalBits(n) {\n        return ((n - (n | 0)) * 0x100000000) | 0;\n    }\n\n    var n = 2;\n    var nPrime = 0;\n    while (nPrime < 64) {\n        if (isPrime(n)) {\n            if (nPrime < 8) {\n                H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));\n            }\n\n            K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));\n\n            nPrime++;\n        }\n\n        n++;\n    }\n}());\n\n// Reusable object\nvar W = [];\n\n/**\n * SHA-256 hash algorithm.\n */\nvar SHA256 = C_algo.SHA256 = Hasher.extend({\n    _doReset: function () {\n        this._hash = new WordArray.init(H.slice(0));    // eslint-disable-line\n    },\n\n    _doProcessBlock: function (M, offset) {\n        // Shortcut\n        var H = this._hash.words;\n\n        // Working variables\n        var a = H[0];\n        var b = H[1];\n        var c = H[2];\n        var d = H[3];\n        var e = H[4];\n        var f = H[5];\n        var g = H[6];\n        var h = H[7];\n\n        // Computation\n        for (var i = 0; i < 64; i++) {\n            if (i < 16) {\n                W[i] = M[offset + i] | 0;\n            }\n            else {\n                var gamma0x = W[i - 15];\n                var gamma0 = ((gamma0x << 25)\n                    | (gamma0x >>> 7)) ^ ((gamma0x << 14)\n                    | (gamma0x >>> 18)) ^ (gamma0x >>> 3);\n\n                var gamma1x = W[i - 2];\n                var gamma1 = ((gamma1x << 15)\n                    | (gamma1x >>> 17)) ^ ((gamma1x << 13)\n                    | (gamma1x >>> 19)) ^ (gamma1x >>> 10);\n\n                W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];\n            }\n\n            var ch = (e & f) ^ (~e & g);\n            var maj = (a & b) ^ (a & c) ^ (b & c);\n\n            var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));\n            var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25));\n\n            var t1 = h + sigma1 + ch + K[i] + W[i];\n            var t2 = sigma0 + maj;\n\n            h = g;\n            g = f;\n            f = e;\n            e = (d + t1) | 0;\n            d = c;\n            c = b;\n            b = a;\n            a = (t1 + t2) | 0;\n        }\n\n        // Intermediate hash value\n        H[0] = (H[0] + a) | 0;\n        H[1] = (H[1] + b) | 0;\n        H[2] = (H[2] + c) | 0;\n        H[3] = (H[3] + d) | 0;\n        H[4] = (H[4] + e) | 0;\n        H[5] = (H[5] + f) | 0;\n        H[6] = (H[6] + g) | 0;\n        H[7] = (H[7] + h) | 0;\n    },\n\n    _doFinalize: function () {\n        // Shortcuts\n        var data = this._data;\n        var dataWords = data.words;\n\n        var nBitsTotal = this._nDataBytes * 8;\n        var nBitsLeft = data.sigBytes * 8;\n\n        // Add padding\n        dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n        dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\n        dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;\n        data.sigBytes = dataWords.length * 4;\n\n        // Hash final blocks\n        this._process();\n\n        // Return final computed hash\n        return this._hash;\n    },\n\n    clone: function () {\n        var clone = Hasher.clone.call(this);\n        clone._hash = this._hash.clone();\n\n        return clone;\n    }\n});\n\n/**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n *     var hash = CryptoJS.SHA256('message');\n *     var hash = CryptoJS.SHA256(wordArray);\n */\nC.SHA256 = Hasher._createHelper(SHA256);\n\n/**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n *     var hmac = CryptoJS.HmacSHA256(message, key);\n */\nC.HmacSHA256 = Hasher._createHmacHelper(SHA256);\n\nmodule.exports = CryptoJS.SHA256;\n","/**\n * @file vendor/crypto.js\n * @author leeight\n */\n\nvar HmacSHA256 = require(37);\nvar Hex = require(36).enc.Hex;\n\nexports.createHmac = function (type, key) {\n    if (type === 'sha256') {\n        var result = null;\n\n        var sha256Hmac = {\n            update: function (data) {\n                /* eslint-disable */\n                result = HmacSHA256(data, key).toString(Hex);\n                /* eslint-enable */\n            },\n            digest: function () {\n                return result;\n            }\n        };\n\n        return sha256Hmac;\n    }\n};\n\n\n\n\n\n\n\n\n\n","/**\n * @file vendor/events.js\n * @author leeight\n */\n\n/**\n * EventEmitter\n *\n * @class\n */\nfunction EventEmitter() {\n    this.__events = {};\n}\n\nEventEmitter.prototype.emit = function (eventName, var_args) {\n    var handlers = this.__events[eventName];\n    if (!handlers) {\n        return false;\n    }\n\n    var args = [].slice.call(arguments, 1);\n    for (var i = 0; i < handlers.length; i++) {\n        var handler = handlers[i];\n        try {\n            handler.apply(this, args);\n        }\n        catch (ex) {\n            // IGNORE\n        }\n    }\n\n    return true;\n};\n\nEventEmitter.prototype.on = function (eventName, listener) {\n    if (!this.__events[eventName]) {\n        this.__events[eventName] = [listener];\n    }\n    else {\n        this.__events[eventName].push(listener);\n    }\n};\n\nexports.EventEmitter = EventEmitter;\n\n","/**\n * @file vendor/helper.js\n * @author leeight\n */\n\nfunction pad(number) {\n    if (number < 10) {\n        return '0' + number;\n    }\n    return number;\n}\n\nexports.toISOString = function (date) {\n    if (date.toISOString) {\n        return date.toISOString();\n    }\n    return date.getUTCFullYear()\n        + '-' + pad(date.getUTCMonth() + 1)\n        + '-' + pad(date.getUTCDate())\n        + 'T' + pad(date.getUTCHours())\n        + ':' + pad(date.getUTCMinutes())\n        + ':' + pad(date.getUTCSeconds())\n        + '.' + (date.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5)\n        + 'Z';\n};\n\nexports.toUTCString = function (date) {\n    var isoString = exports.toISOString(date);\n    return isoString.replace(/\\.\\d+Z$/, 'Z');\n};\n\n\n\n\n\n\n\n\n\n\n","/**\n * @file vendor/path.js\n * @author leeight\n */\n\nvar u = require(46);\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe = /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;\n\nfunction splitPath(filename) {\n    return splitPathRe.exec(filename).slice(1);\n}\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n    // if the path tries to go above the root, `up` ends up > 0\n    var up = 0;\n\n    for (var i = parts.length - 1; i >= 0; i--) {\n        var last = parts[i];\n\n        if (last === '.') {\n            parts.splice(i, 1);\n        }\n        else if (last === '..') {\n            parts.splice(i, 1);\n            up++;\n        }\n        else if (up) {\n            parts.splice(i, 1);\n            up--;\n        }\n    }\n\n    // if the path is allowed to go above the root, restore leading ..s\n    if (allowAboveRoot) {\n        for (; up--; up) {\n            parts.unshift('..');\n        }\n    }\n\n    return parts;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) {\n        return str.substr(start, len);\n    }\n    : function (str, start, len) {\n        if (start < 0) {\n            start = str.length + start;\n        }\n        return str.substr(start, len);\n    };\n\nexports.extname = function (path) {\n    return splitPath(path)[3];\n};\n\nexports.join = function () {\n    var paths = Array.prototype.slice.call(arguments, 0);\n    return exports.normalize(u.filter(paths, function (p, index) {\n        if (typeof p !== 'string') {\n            throw new TypeError('Arguments to path.join must be strings');\n        }\n        return p;\n    }).join('/'));\n};\n\nexports.normalize = function (path) {\n    var isAbsolute = path.charAt(0) === '/';\n    var trailingSlash = substr(path, -1) === '/';\n\n    // Normalize the path\n    path = normalizeArray(u.filter(path.split('/'), function (p) {\n        return !!p;\n    }), !isAbsolute).join('/');\n\n    if (!path && !isAbsolute) {\n        path = '.';\n    }\n    if (path && trailingSlash) {\n        path += '/';\n    }\n\n    return (isAbsolute ? '/' : '') + path;\n};\n\n\n\n\n\n\n\n\n\n","/**\n * @file src/vendor/q.js\n * @author leeight\n */\nvar Promise = require(34);\n\nexports.resolve = function () {\n    return Promise.resolve.apply(Promise, arguments);\n};\n\nexports.reject = function () {\n    return Promise.reject.apply(Promise, arguments);\n};\n\nexports.all = function () {\n    return Promise.all.apply(Promise, arguments);\n};\n\nexports.fcall = function (fn) {\n    try {\n        return Promise.resolve(fn());\n    }\n    catch (ex) {\n        return Promise.reject(ex);\n    }\n};\n\nexports.defer = function () {\n    var deferred = {};\n\n    deferred.promise = new Promise(function (resolve, reject) {\n        deferred.resolve = function () {\n            resolve.apply(null, arguments);\n        };\n        deferred.reject = function () {\n            reject.apply(null, arguments);\n        };\n    });\n\n    return deferred;\n};\n\n\n\n\n\n\n\n\n\n\n","/**\n * @file src/vendor/querystring.js\n * @author leeight\n */\n\nvar u = require(46);\n\nfunction stringifyPrimitive(v) {\n    if (typeof v === 'string') {\n        return v;\n    }\n\n    if (typeof v === 'number' && isFinite(v)) {\n        return '' + v;\n    }\n\n    if (typeof v === 'boolean') {\n        return v ? 'true' : 'false';\n    }\n\n    return '';\n}\n\nexports.stringify = function stringify(obj, sep, eq, options) {\n    sep = sep || '&';\n    eq = eq || '=';\n\n    var encode = encodeURIComponent; // QueryString.escape;\n    if (options && typeof options.encodeURIComponent === 'function') {\n        encode = options.encodeURIComponent;\n    }\n\n    if (obj !== null && typeof obj === 'object') {\n        var keys = u.keys(obj);\n        var len = keys.length;\n        var flast = len - 1;\n        var fields = '';\n        for (var i = 0; i < len; ++i) {\n            var k = keys[i];\n            var v = obj[k];\n            var ks = encode(stringifyPrimitive(k)) + eq;\n\n            if (u.isArray(v)) {\n                var vlen = v.length;\n                var vlast = vlen - 1;\n                for (var j = 0; j < vlen; ++j) {\n                    fields += ks + encode(stringifyPrimitive(v[j]));\n                    if (j < vlast) {\n                        fields += sep;\n                    }\n\n                }\n                if (vlen && i < flast) {\n                    fields += sep;\n                }\n            }\n            else {\n                fields += ks + encode(stringifyPrimitive(v));\n                if (i < flast) {\n                    fields += sep;\n                }\n            }\n        }\n        return fields;\n    }\n\n    return '';\n};\n","/**\n * ag --no-filename -o '\\b(u\\..*?)\\(' .  | sort | uniq -c\n *\n * @file vendor/underscore.js\n * @author leeight\n */\n\nvar isArray = require(5);\nvar noop = require(10);\nvar isNumber = require(13);\nvar isObject = require(14);\n\nvar stringTag = '[object String]';\nvar objectProto = Object.prototype;\nvar objectToString = objectProto.toString;\n\nfunction isString(value) {\n    return typeof value === 'string' || objectToString.call(value) === stringTag;\n}\n\nfunction isFunction(value) {\n    return typeof value === 'function';\n}\n\nfunction extend(source, var_args) {\n    for (var i = 1; i < arguments.length; i++) {\n        var item = arguments[i];\n        if (item && isObject(item)) {\n            var oKeys = keys(item);\n            for (var j = 0; j < oKeys.length; j++) {\n                var key = oKeys[j];\n                var value = item[key];\n                source[key] = value;\n            }\n        }\n    }\n\n    return source;\n}\n\nfunction map(array, callback, context) {\n    var result = [];\n    for (var i = 0; i < array.length; i++) {\n        result[i] = callback.call(context, array[i], i, array);\n    }\n    return result;\n}\n\nfunction foreach(array, callback, context) {\n    for (var i = 0; i < array.length; i++) {\n        callback.call(context, array[i], i, array);\n    }\n}\n\nfunction find(array, callback, context) {\n    for (var i = 0; i < array.length; i++) {\n        var value = array[i];\n        if (callback.call(context, value, i, array)) {\n            return value;\n        }\n    }\n}\n\nfunction filter(array, callback, context) {\n    var res = [];\n    for (var i = 0; i < array.length; i++) {\n        var value = array[i];\n        if (callback.call(context, value, i, array)) {\n            res.push(value);\n        }\n    }\n    return res;\n}\n\nfunction indexOf(array, value) {\n    for (var i = 0; i < array.length; i++) {\n        if (array[i] === value) {\n            return i;\n        }\n    }\n    return -1;\n}\n\nfunction omit(object, var_args) {\n    var args = isArray(var_args)\n        ? var_args\n        : [].slice.call(arguments, 1);\n\n    var result = {};\n\n    var oKeys = keys(object);\n    for (var i = 0; i < oKeys.length; i++) {\n        var key = oKeys[i];\n        if (indexOf(args, key) === -1) {\n            result[key] = object[key];\n        }\n    }\n\n    return result;\n}\n\nfunction pick(object, var_args, context) {\n    var result = {};\n\n    var i;\n    var key;\n    var value;\n\n    if (isFunction(var_args)) {\n        var callback = var_args;\n        var oKeys = keys(object);\n        for (i = 0; i < oKeys.length; i++) {\n            key = oKeys[i];\n            value = object[key];\n            if (callback.call(context, value, key, object)) {\n                result[key] = value;\n            }\n        }\n    }\n    else {\n        var args = isArray(var_args)\n            ? var_args\n            : [].slice.call(arguments, 1);\n\n        for (i = 0; i < args.length; i++) {\n            key = args[i];\n            if (object.hasOwnProperty(key)) {\n                result[key] = object[key];\n            }\n        }\n    }\n\n    return result;\n}\n\nfunction bind(fn, context) {\n    return function () {\n        return fn.apply(context, [].slice.call(arguments));\n    };\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString');\nvar dontEnums = ['toString', 'toLocaleString', 'valueOf', 'hasOwnProperty',\n    'isPrototypeOf', 'propertyIsEnumerable', 'constructor'];\n\nfunction keys(obj) {\n    var result = [];\n    var prop;\n    var i;\n\n    for (prop in obj) {\n        if (hasOwnProperty.call(obj, prop)) {\n            result.push(prop);\n        }\n    }\n\n    if (hasDontEnumBug) {\n        for (i = 0; i < dontEnums.length; i++) {\n            if (hasOwnProperty.call(obj, dontEnums[i])) {\n                result.push(dontEnums[i]);\n            }\n        }\n    }\n\n    return result;\n}\n\nexports.bind = bind;\nexports.each = foreach;\nexports.extend = extend;\nexports.filter = filter;\nexports.find = find;\nexports.isArray = isArray;\nexports.isFunction = isFunction;\nexports.isNumber = isNumber;\nexports.isObject = isObject;\nexports.isString = isString;\nexports.map = map;\nexports.omit = omit;\nexports.pick = pick;\nexports.keys = keys;\nexports.noop = noop;\n\n\n\n\n\n\n\n\n\n\n\n\n\n","/**\n * @file vendor/util.js\n * @author leeight\n */\n\nvar u = require(46);\n\nexports.inherits = function (subClass, superClass) {\n    var subClassProto = subClass.prototype;\n    var F = new Function();\n    F.prototype = superClass.prototype;\n    subClass.prototype = new F();\n    subClass.prototype.constructor = subClass;\n    u.extend(subClass.prototype, subClassProto);\n};\n\nexports.format = function (f) {\n    var argLen = arguments.length;\n\n    if (argLen === 1) {\n        return f;\n    }\n\n    var str = '';\n    var a = 1;\n    var lastPos = 0;\n    for (var i = 0; i < f.length;) {\n        if (f.charCodeAt(i) === 37 /** '%' */ && i + 1 < f.length) {\n            switch (f.charCodeAt(i + 1)) {\n                case 100: // 'd'\n                    if (a >= argLen) {\n                        break;\n                    }\n\n                    if (lastPos < i) {\n                        str += f.slice(lastPos, i);\n                    }\n\n                    str += Number(arguments[a++]);\n                    lastPos = i = i + 2;\n                    continue;\n                case 115: // 's'\n                    if (a >= argLen) {\n                        break;\n                    }\n\n                    if (lastPos < i) {\n                        str += f.slice(lastPos, i);\n                    }\n\n                    str += String(arguments[a++]);\n                    lastPos = i = i + 2;\n                    continue;\n                case 37: // '%'\n                    if (lastPos < i) {\n                        str += f.slice(lastPos, i);\n                    }\n\n                    str += '%';\n                    lastPos = i = i + 2;\n                    continue;\n            }\n        }\n\n        ++i;\n    }\n\n    if (lastPos === 0) {\n        str = f;\n    }\n    else if (lastPos < f.length) {\n        str += f.slice(lastPos);\n    }\n\n    return str;\n};\n"]}